Looking at the Ethereum IDE - Mix

Transcript

[Music] [Laughter] so this talk is about the um the IDE the integrated development environment or the tool that you use to develop things um with the ethereum uh framework I'm going I say things what I actually mean is deps um the talk has been given a name by uh sorry not the talk the IDE has been given a name by Yan who is uh he started development on it uh not long ago and uh I got it right yeah

mix um that's the uh name for the uh or the code name for the project okay so like all uh like all things it is a um an attempt to solve a problem or at least provide some degree of a solution so the problem in this case is that writing software is hard um we we have ways of making it easier um Sven uh mentioned some of those ways in his talk as did Kristoff and we have we have services that help us as well and we also have uh various bits of Technology um there are some examples but these

things are often uh quite kind of disperate um for instance when I'm in my editor um and I'm working on a feature uh that does not directly integrate with my feature manager which is uh at least for me uh GitHub and specifically the GitHub issue system so the I of ID stands for integrated and the idea of integrated of course to bring all these things into one place now in addition to to just general software development it turns out that actually writing decentralized apps is even harder so firstly it's harder conceptually because decentralized applications are just not things that we're used to

developing right then there it takes even a a seasoned programmer um a long time to really understand how Bitcoin works why it works um often uh you find people asking uh when you talk about Bitcoin blockchain technology in general well hold on what about the security what firewalls do you need to have in place for Bitcoin to work it's like well this isn't the right question you're in the wrong Paradigm you got to you got to shift your paradig and it's the same with decentralized applications um and for that I think I mentioned some of stuff in in solidity and there's actually another talk I did which I'll probably give a again at some point about uh uh having um different amounts

of information available to different people and different uh different decentralized applications and how they all collaborate but any anyway it is a different Paradigm so we have um a diverse debugging environment we're not dealing with a single language or a single machine or a single set of State um we have all of this stuff going on it's very hard to collect it all together as anyone who has used uh LF zero to develop uh DS will will know and and hate um yes the last point is uh is like the what's what's happening on the on the system it's really easy to get the state of a system when you've got just a a traditional system a system where all

the state it's basically memory and hard disk right and when you've um when you have that you can use a debugger you can ask the debugger hey what's the what's the value of this variable well it's a bit different when you when you're dealing with decentralized applications because it might not be around it's hard to set things up exactly so with with decentralized applications at least the decentralized applications that ethereum 1. not will be you know thinking about and supporting and this notion of of uh of web 3 and the collection of these three sort of um Technologies so we have the uh the ethereum blockchain so they need to um um to to launch a transaction but debug the transaction but do so with the

blockchain in a particular State it's no good if the blockchain can be in any state because that could easily affect what your assertions are with the debugging um environment similarly with uh with the two other protocols whisper and SW SW it's important that you you don't just launch or debug or test your your decentralized application on on just any old um uh instantiation of whisper or on the the present sort of live net whisper or even the test net whisper because there may be messages there that you don't expect and that alter your base assertions and assumptions with the uh with the debugging environment basically as we move to the notion of unit tests we need to isolate things and we need to have harnesses for these things and a very easy way of operating with

them same with swamp so we try and we try and solve this so here's a uh a basic look at what the um what a first a first uh attempt first effort at the ID could could look like um you got your code this might be a solidity contract that's that's what it is here and then you've got uh what it looks like um ultimately so maybe you're hosting some HTML file on your on your machine and it's just browsing that file and this maybe this file um uh in some way operates with this but it's very

hard to really understand how this is working it's uh it would you'd have to do a lot of the the grunt work manually you would have to make sure that this points at wherever this goes into the blockchain pain you would have to submit that to the blockchain of course and the debugging would happen entirely separately now the as I go on and show more and more of what we plan this stuff isn't necessarily ethereum 1 Point not it will take some time to develop out um of course we'll be doing it in Milestones there are some features that are higher priority than others um in the same way that solidity all of solidity isn't isn't one point not it's we're not going to manage it by Mark um certainly the uh the invariance

the static checking is going to sort of run into the 2.9 schedule but yeah it's uh it's planned so first thing to do is to say right um adap is something that is not just a contract it's a bunch of other stuff it's the JavaScript the the front end stuff the stuff that holds it together uh holds the user experience together it's a bunch of HTML bunch of CSS ultimately of course maybe if we move on to a qml uh optional optionally qml front end then you can swap some of this out for qml at the moment we're just dealing with web Technologies and that's mostly strategic decision so we want some sort of project management we want some way so some way

of sort of um holding together the contracts for a particular decentralized application and then the other sort of more um more front end uh things so in this it's a bit blurry can we can can we alter the focus slightly might maybe uh no yeah that's not like it so uh in this case we've got a couple of contracts we've got a Javascript file and then um and then we've got some Styles and whatnot notably the way that we want to take the ID is to remove um the overburden of man of file management so file management was something that sort of invented in

the I don't know 60s or 70s I guess um whereby we group lumps of data into files and store them generally hierarchically on a on a filing system now that's fine when you need something that's lowlevel but when we're dealing with with you know highlevel Concepts like projects and contracts we really don't need to be falling back into lowlevel Concepts like files and groups of bites so um although it's very hard to get around this for uh for the web for the web technology stuff so it's very hard to sort of reference something like a apeg file without actually having a file for the contract well we have a name for a contract and so we can avoid

actually explicitly dealing with files we can actually just just have contracts by the name and if you rename your contract then sort of hidden behind the scenes maybe a file gets renamed somewhere but you never need to know so if we add a bit more a bit more integration in you can see we've got some a bit of extra stuff now we've got this idea of Team Activity one of the key things of uh of developing software is is collaboration with other members of a team that helps you develop software um we have this notion of what you're currently working on a developer well maybe there's some awesome Superstar developers that can de work on two or three or four features literally at the same time but in general we tend

to address one issue or one feature at once um so we have this idea of what you're working on we also have things like the documentation integrated um and Contex sensitive if you notice we've also gotten rid of the uh ah oh oh de that's not good what happened there uh we have this notion of yes there we are um we have this notion of what file we're at but we've suddenly removed the Local Host stuff because the ID is going to host the file the project as a whole the DAP right and

we won't have to care about where where it's hosting it because that's taken care of by the ID kind of in the same way that when you're in I don't know Visual Studio whatever you hit F5 you don't actually care about where in the file system the executable happens to be that's running the fact of the matter is that it is running and that's all you care about as a developer add on a little more and we can start to see things like the tests that we have now this all happens as you'll notice there's no buttons right this all happens and it's sensitive to as you type so as you type as you update the code as you add more tests as you remove tests as you um as you change the uh the code there um these update

automatically we have contact sensitive information annotation actually built into the textual representation of the program in this case it's telling us that uh the something wrong here that uh number Founders is not a number it used to be an integer but it became not a number in line nine so it's actually tracking the state of variables as the debugging happens so the idea is that as it's debugging as you are not allowed to to edit the thing the background turns yellow and we we get context sensitive information we get annotation directly in the editor now we can do this um basically because we have full compiler integration one of the key points of the

solidity project was to separate the compiler executable the thing that turns some source code into some object code and the um the as interface so the as for those of you not compiler writers is the abstract syntax tree and this is basically a mid-level representation of the actual program so we're used to we're used to sort of we're used to thinking of programs in terms of text so if I ask an average brid developer hey you know show me that show me the hello program what they'll do is they'll write out some text and they'll say there you go now that's kind of the program you might argue it's a it's a projection or a representation of the program but it's not canonically the program one of the

reasons that you might use to argue this point is that well I could alter this program in numerous ways Whit space removal for instance um yet it wouldn't change what the program is it wouldn't change if we're going to get technical it wouldn't CH the as still all it still gets passed and understood as the same the same actual program now there are group of um a group of uh pieces of software that actually deal withs and when you edit the program you do literally edit the program you don't edit the source code so these are called structural editors or language workbenches we're not going to be doing a language workbench because that's kind of outside the scope but this may ultimately change into a structural editor whereby suddenly we

won't have to worry about things like uh White space or uh code formatting being in the wrong way these things will automatically get uh automatically get rendered in the way that the user actually wants to render them the developer wants to render them and you know it will default to some canonical representation probably some some uh basic representation that everyone agrees on but ultimately it's something that people can alter if you don't like tabs if you like spaces then fine you alter it and it it renders it as with tabs and not spaces if you prefer your parentheses to be on the same line or on the next line you can alter that as well the idea is this is all transparent and the thing that goes into GitHub is just the canonical representation okay is

that not working no uh ah okay right so that was that seemed to be Google probably our iffy internet connection okay so just to go over some of these features in turn document integration so as you have I don't know cursor is over a function or maybe as you're writing you're calling into a function um you'll get pop-up documentation now this is this can be done by virtue of having a contract sort of database decentralized

database for contracts that stores the documentation so we heard some of the ideas from Andreas a few days ago of how this might be implemented and the idea is that the ID actually goes to this place it understands through some sort of uh URI system um and registration system what the contract is um again in tandem um this is this is achieved through using the as um from the solidity library and uh it's able to actually pull out the documentation from that repository if necessary it could go off on the Internet or the decentralized network or swarm or wherever and grab the documentation the idea is of course that

it also is able to pull out the documentation for the for the program and tell you hey hold on you've only documented three out of the four functions or this invariant you just added you didn't document it properly or you know maybe you're missing a parameter maybe there's a parameter for the function and your documentation actually doesn't utilize the value of that parameter in documenting it to the user and that's obviously a a grave error because the user probably wants to know it's probably quite important test integration tests along so so initially tests will be a very important part of contract development hopefully eventually we'll move over to a more formal system but initially it's going to be very important that the

developers of contracts write a lot of tests and that these tests can be be viewed and and checked by Auditors of contracts to make tests ever more useful for developers they should be as dynamic as possible so it's a bit of a pain to write tests first because often what the interface for a particular function or method or contract is differs um after you finished the contract from when you started the contract because you simply don't have full knowledge until you've written most of it so although uh testing after writing the tests after development is perhaps um there are Arguments for writing it um before you finish the full uh contract but there are also very good Arguments for not

writing them before you've started the contract so uh writing tests as you develop the contract is probably going to be a a sensible Way Forward and the way to encourage developers to do that I assert is to uh make the tests as dynamic as possible so sometimes I'll be coding a feature I'll want to debug that feature to get a bit of a better idea and test certain insertions that I'm making well this should be a very Dynamic a very quick way of adding extra tests as you develop to make sure that the assertions that you're you're making as you develop are indeed true as you type as you alter the contract rather than just testing you know maybe when you compile or when you commit or when you push it tests

everything as you type if you make a if you type a bunch of stuff you add a new function then before you've even compiled anything you're told hey hold on this breaks that earlier test you get a little warning compiler integration is going to be very important again as I said before solidity was always devised to be a library and not simply a compiler and because it's a library we're able to get structured information from it from the solidity passer and the solidity pass tree analyzer so you can get this as and you can have all of the references you need which is to say you can you can say that this um identifier here that corresponds

to this bite position going to this bite position on line 24 is actually a variable that is referenced uh referencing the um the parameter uh of name campaign ID to this function you can get that information and when you can get that information you can do all sorts of uh cool things that are only kind of possible in very certain situations with existing Technologies um such as uh refactor various types of refactoring variable renaming and generally altering the abstract syntax tree altering the program in logical well- defined ways that are uh effectively guaranteed to be neutral Transformations

um so uh because we we're integrating with a compiler we can also as you type check for things like code health so the warnings that it generates maybe even compile errors we can take as you type that in variance so these are sort of static assertions or um assertions made over the entire lifetime or State uh or all possible states of the contract are true and we can have um within the code itself a sort of I don't know massive red box or a massive cross when uh an alteration you make actually fails an invariant we can derive code structure and render it in a way that the user is going to find useful perhaps as a um I don't know if many of you use editors

that have a a sort of zoomed out view of the program code or syntax highlighted you're familiar with that so the idea is well that that's that's okay that's kind of good it sort of gives you a a nice visual representation of the total amount of code but what we can also do is we can add to that we can take the abstract syntax tree what we can do is is render a uh non-textual representation a sort of diagrammatic representation or a structural representation and place that at the side and that's going to be a bit more information dense um and finally as I mentioned earlier we can do things like canonical code formatting which is sort of a a halfway step to actual structural editing and canonical code formatting

what I mean by that is basically when you make an alteration to the code um it automatically reformats the code in the way that is actually canonical so you don't have any of these problems with style a you coding that's coding standards as as the C++ developers know I'm kind of tough on these and uh this effectively uh removes that as as a contention um now I don't know if any of you uh it probably shows my age a little uh are familiar with the Amos programming environment there an early um uh something early on the Amiga you can make your computer games it's kind of a form of basic um that actually already had this so this this stuff that I'm I'm mentioning is is very little of it is uh at all um sort of new or anything and that was in the what mid

'90s early '90s late ' 80s uh you know and you type a line of code you press enter and it would just format the code canonically it's like yeah it's really sensible why do we why do we go back to the 70s all too often um Okay so we've also got like things like debugger integration because we know the abstract syntax tree because we know all of this stuff we have absolutely full knowledge of what's going on in the code we can do all sorts of cool stuff like as you debug annotation for things like State what what value are these variables right now well we can actually show that so there could be for inance you hold down control shift and suddenly the code expands into uh equals 5 for instead of uwing Campa ID it becomes uwing campaign equals 5 maybe the equals 5 is in

italics and some uh variable with font so that we know it's not actually literally equals 5 in the code but you can start to imagine that we can actually annotate this code with upto-date contact sensitive information directly from the debugger that is just kind of if not if not impossible very difficult to do with existing tools um assertion truth again is similar something similar to the invariant we can actually put crosses where assertions fail and this could be integrated into the test environment in order that when you're when you're running tests you get an immediate immediate visualization of where the test is going wrong you can go into State integration transaction integration the blockchain

um integration so this is where we you know we are developing in this this kind of new environment this environment where there's a a lot of other stuff going on so we need to integrate this stuff into the into the development environment and really sort of wrap all around it so we've got full at your fingertips um control as well as obviously transparent handling of various grunt tasks wherever possible so we can um one of the most important things is to be able to test and debug with very particular um states of the blockchain it's no good saying well we'll just test with the the current state of the main main net that's that's crazy all sorts of things might be going on that you just can't predict um you may not even have an

internet connection but similarly they're doing it with a test net is is no good either for the same reasons um so we want to be able to start um debugging control in a very controlled fashion we want to be able to pick out which block that we want to debug on we want to be able to specify hey maybe I want to debug on a chain that's empty we want to be able to specify what states we want to be deogam maybe it's never was a maybe it's not a not um maybe it was never in existence and we just want to sort of create this state this new genesis state if you like and debug on that same with the transaction integration maybe we want the the the the the transaction that we're actually going to debug to follow several other transactions first so we can make sure

that the block has say five transactions first and then debug our transaction just to set up the state into exactly what we need exact with full control over it um and again blockchain and swarm integration so that there's a onestep deploy right deployment could very easily be an absolute pain in the ass and very error prone we need to uh really get on top of that and have basically just a button that's you hit it it runs a deploy script that's easily creatable and what was I um yes it's easily creatable and can do whatever you need so um what it might do

for instance is uh we already have something like this in the C++ codebase for anyone who's familiar with the standard Services the things like name registration the config contract um the coin The Exchange um that's actually all just the Javascript file that I run whenever there's a new chain created and it it it deploys all this stuff well we need a really easy way of creating this um and running it and of course selecting whether we want to run it on the test net or the main net um very very important integration is that with with uh uh with source code uh Version Control tools these are these are you know absolute life blood life blood of programmers and have been for some time now um yet integration in

editors is often pretty minimal yay I can commit because I made a change I mean this is really basic stuff all it's doing is basically do it running a command G commit we need something a bit better we need something that follows our workflow a bit better and encourages us to to to Really commit or use these tools um optimally so one thing Google brought in a while ago with their their Google Docs um infrastructure was the idea of having a uh a permanent undo stack or really tracking all of the changes so what they've what they've done is they've uh they've taken the notion of control Z of and do and they've bundled it with the notion of Version Control so now when you when you say right revision history it will give

you um an undo history SC scanning all the way back to the very beginning of the document why don't we do that we've got G it's pretty uh it's pretty efficient certainly efficient enough for our needs no reason just nobody's done it yet um currently working on so with Git with the commits with branches you tend to say right there's an issue I create a new Branch I I'm going to I'm going to I don't know it's a feature or it's a bug fix um you'll commit to that Branch a few times and you'll generally merge into the branch that you came from well maybe this is the branch that you came from this is the branch that your your you know your your bug fix Branch maybe it's connected to an issue let's just build it into the

workflow let's automate this stuff as much as possible and put the control put the put what the programmer needs to do focus focus on what they want to tell not what they have to do yeah we don't want the programmer to work around tools we want tools to work around the programmer similarly the contract repository integration so uh hearkening back to what Andreas was saying a few days ago with the with the documentation system this should this should just pull that information in and we've got the information to to collate with that so let's just put the ends together connect it all up and really give the developer a um that information at their fingertips automatically GitHub is a great service

right for open source developers I mean has anybody here not used GitHub that is a developer no um it's a great service but it's it's disjoint I have to go to the web browser and use GitHub and then I go to my emac or or cute Creator or whatever VI whatever it is and I I use I I edit the code why can't I do both at the same time GitHub is very clearly a programmer tool editors a very clear programmer tools they're dealing with the same stuff they should be integrated team activity activity is is

largely development as I'm developing I I want to know what other developers are doing and whether it's going to affect what it is that I'm doing it needs to be integrated if I'm working on an issue and somebody else is reporting hey this issue this bug I've got some more information I've been I've been you know testing it I've got some more information I don't want to have to sort of I don't know finish half hour of work go onto the web browser click on something click on something else get into the issue find that they've posted oh well it was that no I want it right there in front of me so when we have um when we have the when we have real GitHub integration what we'll be able to do is Click right project fork in our

editor in our development environment at the end okay and when I do that it will go to iub it will Fork that it will put it under my my reposit my accoun in GitHub it will create a new repository it will open it all up and I'll be good to go should do the same for distribution when I want to uh when I want to distribute it's already on GitHub and I should just be able to click a link give it to someone else and they can Fork if they want to issue integration GitHub issues are great right uh people already use issues for slightly more than they were designed with their of waffle waffle. the Canan board thing that that utilizes issues as Bas as it's underlying database

effectively um why don't why don't IDs do the same I mean all right you might argue the skub integration you need the Internet for yeah but most of the time developers have the internet and when they don't they can there should be an offline option um so when we're doing task feature and project management let's use issues when we're doing collaboration let's use this this system it's already built for us API there so that's some of the ideas that we have that we want to put in action over the coming 12 18 who those months um any questions so are you only going to be able to work on the solidity code or are you going to give some you know L

editing capabilities as well at present it's going to be designed mostly for solidity but there's no reason why ultimately we can't add an abstraction uh platform to allow it to be used for other code as well um what I would like to see is uh a multilanguage support So specifically JavaScript as well because JavaScript is going to be a very important part of this and from JavaScript you're going to want to call into contract so you're going to want some form of as analysis for JavaScript so that you can do all of that cool documentation stuff and you know parameter um parameter upfront head up documentation um so yeah ultimately I'd like to add just mult language support in

there a dependency on contracts that's already deployed and it's not part of your application particular case yeah how you manage this um the uh if I go back a you so this would this would come for under the contract repository integration so the idea is that there's a contract repository it doesn't necessarily store The Source Code of the contract it maybe the the closed Source but what it does store is the Json represent you remember a talk earlier there's a Json representation which is kind of like the header file of a contract right that it would store there's no reason why a developer wouldn't of a contract wouldn't put that in it's free information it's it just helps people interact with their contract and it's

easily derivable um and that would go in the repository alongside some documentation whether it's contributed by the author or or other other people and um and it's that that it would that it would look up via this URI system and the URI system ultimately will be integrated with the um solidity language so you use a URI to um to cast from an address from a generic address into a contract and then when you start call it that's then an object of type this URI this particular contract when you start you know I don't know if the contract's called a a DOT that will bring up the uh the methods that you can call whether it's in JavaScript or solidity stepan is the time to slowly

improve NS Z with this type of feature set or just have a power development uh about own track mix for minute um the latter Al zero is at present um rather a bed of nails it does most things that you can ever need to do but it's it does it in ways that are very much not uh designed around the developer the idea is to have this additional ID um and basically sort of push alth zero into Power us user or people who are just sort of interested in mucking around and viewing the blockchain and really push the ID as the the primary way of developing deps Victor yes so three quick questions first is so

so block right so it's not existing right that is correct yes I mean does it exist in some yes there is uh we're we're just about got to Milestone one I believe is that correct John yeah okay second uh you mentioned that we don't want to deal with F I got a bit scar scar like you obviously people understand what f is what director is is even if you have proper GitHub integration I mean even with GitHub you need to have files and and people understand how to transport maybe their project with the zip anyway it's like BL from so

for example with the contracts it seem to like if you only had the names yeah so um I suppose if you think of it it's not that files won't be used underneath and it's not that ultimately the developer will have access won't have access to their files if they if they want access it's simply that um it shouldn't be necessary to understand the concept of a file because actually it's not it's not it's not actually necessary it shouldn't be a first class citizen it should effectively be an implementation detail that you can drw down to if you want but that you don't have to so with the contracts to take an example um it might be that the contracts are one stored one in each file and the file's name is that contract name do soul I mean that that would be a very sensible

way of doing it um but you know just to mix things up a bit it may be that you store them in the same file um so all contracts may be stored in a single file apprehensive of these magic functions of things um well it might have a see to sort of end up creating a sort of pseudo proprietary format which you don't want so there would be I mean you know it's open source if if it does something really terrible that developers don't like they'll change it um so it's not going to make any anything proprietary but I suppose the point is that um files as a thing don't need to exist um for this and with the notion of Zips well

again it may be that developers want to have a zip in which case they're free to make is it from the directory I mean it's going to be a directory cuz as you said GitHub Works in this way but it doesn't mean that um that it has to be shoved into the developer space now what I specifically want to avoid so that if if you're after a real use case for this it's um I rename a contract and yet the file is still the old name of the contract so if I if I got a contract fo I renamed a bar but they I've still got food. soul now as a as a program I shouldn't be forced to look after my files as well is looking after my Cod exactly but automatic renaming is just as scary so um I would argue that it's it's

considerably less yeah we and the third question can we get rid of the semicolon at the end of the night you have to well we we we could have a separate panel discussion about that uh Le yeah uh I just wanted to make a question regarding integration of some of these features possibly with other editors you mentioned that it's all in the library right now in um so that would integrate with ID directly I guess we would just call the functions of the library but couldn't we also have

at least some like the ASD printing or um other features made uh into the file by S C does some special argument so that other editors can also integrate with some of these features yes and I believe it already does is that correct the format is not really Parable but okay but could me could be made so yeah um yeah I don't yeah why not why not uh the the precise priority of that task would have to be discussed but uh in principle yeah just mentioning because you know we want developers to adapt it then we shouldn't solve no matter how would it is a specific editor on their face sure uh

that won't be the case so they'll always have the command line uh compiler if nothing else Alex um so two questions the first is uh I SW is is swarm integrated at all potentially yes absolutely and uh uh is it integrated in more than one way and um uh what what will happen to the Kens uh I mean it doesn't look like that progress Mar is moving it may feel the worst um as for swarm yes it will be possible to set up within the deployment script or within the test and debugging

environment So within the tests and debug definitions a set of uh key value pairs for swarm for the resources that you might want there oh um what about uh say for chatting about GitHub issues or storing the project itself um well that's right indeed exactly that so click new project it makes a new project in GitHub checks it out and you're good to go yeah yeah oh so uh I guess I guess we could store everything in the get repository somehow um but then that could also I mean you could Mount ipfs locally or we could may

need that's just you might not need the file system uh that's a possibility too uh so I I'm Keen to go with things that are already working for now but uh Daniel uh is it part of the vision for it to become eventually selfhosted I mean to get rid of GitHub and just host it in SW um that's something that could certainly be considered once swarm is again you know orfs which is ver yeah yeah for instance uh span what were your reasons to say okay create a complete new ID instead of just attaching it to Clips or some other ID with

plugins um so mainly because I wanted to avoid um forcing other software into the system and making more dependencies making more things that go wrong more moving Parts I kind of wanted to keep it towards a single uh code base um that we had full control over that made some sense to me regarding um the need to integrate into the blockchain so I know eclipse is pure plug-in and technically you should actually be able to do any of this with it um the other reason of

course is that eclipse is Java based and Java's utterly horrible sorry it's very heavy buy um there's so many things that to do with that second the idea that it's a clip slide you can extend it easily and you can and one main thing because we've got a co- teaching project that seems to be coming up a lot is like collaborative or pair programming um uh with video tutorials side by side you know you can and especially in this sort of area you

might want kind of the legal person or the business person and the contract person you're debating you're writing together um uh it just seems that to extend the the the the the type of users and to get it should maybe be early in I'm sure you're thinking about or things like that to do to do that I mean you mentioned like Google Docs I mean that's classic so what are your plans with regard to collaboratively working um in educational other s with the IDE um so the uh the screenshot whatever it was yeah um is uh a first effort um but yeah uh actually Dynamic pair programming so

having uh seeing the other person's cursor Google lock style um chatting maybe voice over IP at the same time um with what what as you see the other developer altering things yeah I mean absolutely that's what it's all about I want to eventually time uh time will tell good things come to those who wait though uh okay any other questions no cool thank you