IDE 2.0: The Age of Intelligent IDEs
James is a DZone Zone Leader and has posted 507 posts at DZone. You can read more from them at their website. View Full User Profile
The latest innovation in the Eclipse space that I'd like to share with you is Code Recommenders. Already available as a plugin for Eclipse, Code Recommenders provides intelligent code completion. Rather than giving you all possible methods for code completion, this plugin proposes the methods that you probably need at the top of the list, with a rating of how applicable each method is. To see Code Recommenders in action, see the following screencast.
If that interests you, then you'll want to read "IDE 2.0: Collective Intelligence in Software Development", a paper from the Code Recommenders team. The idea behind this is that IDEs should take advantage of collective intelligence:
"Figure 1b shows our vision of the near future: IDEs will support developers through integration with a global knowledge base. This knowledge base will receive information from implicit and explicit user feedback. By implicit feedback we mean anonymized usage data that the cross-linked IDEs will send to the knowledge base automatically and spontaneously (in the figure, we represent such spontaneous activity through dashed arrows). The knowledge base will also comprise explicit user feedback in the form of user-written documentation, error reports, manuals, etc. In this work, we will show that such data can help, for example, to improve ranking heuristics, or to focus developer activity. "
The core principles proposed include advances in intelligent code completion, where the recommender systems learn from what a group of developers are using. They also bring up the concepts of better code snippet integration and extended documentation.
These ideas along with other advances in Eclipse projects such as Mylyn, ECF and e4 all point to a gradual change in how we use IDEs. Eclipse has proved itself as an ecosystem for this type of innovation, adding in functionality here and there that helps us collaborate better and take advantage of external systems.
- Login or register to post comments
- 11879 reads
- Printer-friendly version
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)
Comments
Loren Kratzke replied on Thu, 2010/09/02 - 12:01pm
Chris Roberts replied on Thu, 2010/09/02 - 1:42pm
in response to: qphase
Suresh Murthy replied on Fri, 2010/09/03 - 3:31am
Hi James,
This is really an exiciting idea which look forward to. From what I understand, I feel the following things would excite me the most:
1. Identify the usage patterns to solve a specific problem by exploiting the common knowledge base:This would mean that there is a re-usability of not just at the level of core language libraries but some commonly used patterns to solve re-curring or mundane tasks. Like for example, If I am looking for adopting a templating solution in my project, I could simply harness from the suggestions or recommendations (I hope that common knowledge base would allow this) by other developers from across the globe. This would mean that I need not go through 100s of forums to get to what I want. I would just have it at one single place. It promotes the re-usability of a complete solution!
2. Seamless collboration in real time:
If the IDEs can be used this way, I feel that the next gen IDEs should promote collaboration seamlessly across development teams or the developer community (separated by geograhies) by not having to leave their IDEs (I mean in real time) since everything is built into your IDE. I am not really sure how this would be but I am basically looking an integrated collboration tool customized for aiding developers to share their code snippets or utlities seamlessly.
3. Harnessing the globally collated data (patterns of usage) to provide customized recommendations:
By collating the data and analyzing the patterns of usage of an IDE it should be possible to give customized recommendations to the users of the IDE worldwide. It would bring in a dramatic change in the productivity (in terms of exploiting the features of an IDE) since one gets to re-use things already done. No need to re-invent the wheel all over again!
I am not sure if these things are already there. If not I would love to have them in the IDEs in the coming days.
Thanks for this post.
Regards,
Suresh S Murthy
Marcel Bruch replied on Fri, 2010/09/03 - 7:52am
Cool post. Thanks for spreading the idea of IDE 2.0 :) Maybe I can add some details...
Loren, it's in fact a bit more than Netbeans (and Eclipse) does. You may have a look on these slides which may give you a better intution of what we are doing there: slides.
I think, Chris summarized the intelligent code completion very well (except that there are not really "pretty complex heuristics" used ;-)
Suresh, you describe many great ideas. I will keep a bookmark on this page to come back later to your points. Just a few notes: The data developers share with each other and the system will always be available for others to reuse, i.e., we will have an open-data access to this usage data. This freely available usage data allows others to build their own tools on top of this.
Here some links if you are interested to get more details:
We are currently preparing the Eclipse project proposal. A draft version with (yet unpolished) contents is available here. If you are interested in the project, just add your name to the "interested parties" section. Please feel free to put any comments on this post or onto the wiki page @ eclipse. We are glad to take you comments :)
All the best,
Marcel
P.S.: We will have a talk at Eclipse Summit Europe in November. Thus, if you attend ESE just chat me up there
Loren Kratzke replied on Sat, 2010/09/04 - 1:15pm
in response to: microbiotic
Agreed, there is much more here than initially meets the eye. Data mining of this sort is potentially very beneficial to developers. I am sure that the minds at Google will be interested in this. Perhaps I would have been more blown away if I saw some J2EE or Spring code examples.
I hope the developers provide enough abstraction for this code to easily function outside of Eclipse. In fact, it would be nice to see an organization level server system that could serve code hints inside a firewall that are unique within an organization (in addition to global hints from the outside), regardless of what IDE is used by the developer - a basic HTTP based protocol that could be implemented by any plugin developer. That would certainly blow my hair back.
Jason Marshall replied on Sat, 2010/09/04 - 6:38pm
I would think recommending existing usage patterns would be exactly what you DON'T want to do.
Any tool that helps people write redundant code, is not one I want certain people to have at their disposal. There's enabling technology, and there's Enabling technology (as in the abnormal psychology term).
Recommending a method based on what methods return the variable assignment I've started... That's good, but it wouldn't be original.
Marcel Bruch replied on Mon, 2010/09/06 - 10:50am
in response to: qphase
LOL. OK, I take away:To blow your hair back, we have to:
(I hope it's summarized more or less correctly) To make it short, we agree on all these points - prioritized in this order.
More showcases:
We will first continue to improve the system to learn usage rules for virtually every framework. Clearly, the system will perform differently for different frameworks and we will see how well such a system could work on Spring and JEE (which leverage things like annotations we did not consider yet).
Too tight Eclipse coupling:
To make IDE 2.0 work we need a tight integration into the IDE and a strong user community. Since Eclipse has a very large and vibrant community we have good chances to see whether the concepts will work in-the-large. However, the services and data will be open to allow other IDEs to leverage these systems too. The technology stack is not fixed yet, but json-based web-services or OSGI remote services may be good candidate that should be consumable by other IDEs too. In the farsighted we may develop ports to other IDEs and suport other languages. But at this time - I think we can all agree - it is a bit too early to commit ourselves to such plans :)
Company knowledge repositories:
Agreed, supporting several knowledge repositories may become an important feature for companies. But let's start with one repositories to get our feet wet with the idea and extensions will follow a later after the concepts have proven valuable. The code itself will be hosted at Eclipse, thus will be open source. Extending Eclipse (or Netbeans) integration is possible at any time. However, I would prefer one repository at the beginning ;)
Thanks for your comments
All the best,
Marcel
Marcel Bruch replied on Tue, 2010/09/07 - 1:22am
in response to: jm28926
Jason, you are right. But I think, what you have in mind is little bit different from what we are trying to achieve.
Clearly, having duplicated code is not the way to go. But how do you reuse existing components? Whenever we reuse a certain framework we have to follow the expectations of that framework, i.e., we have to override and call the right methods in the right places. Unless we follow these expectations our code is unlikely to work properly.
For example: Say, you want to get an instance of the Eclipse WorkbenchHelp and want to register a help context on your JFace WizardPage. How do you achieve that? Clearly, there is some glue code to write but this is something that does not lead to redundant code (at least not in the way that I write ten times the same code in my app). We aim to support developers on learning about and finding this glue code quickly.
Another example. When creating a Button in SWT (or Swing), you have to create an instance, configure it by setting some layout information, give it some text and font, and may add a selection listener. This is what you do for almost all buttons in your code (you may call some methods more or less - but basically you alwaysfollow the same pattern). Would you say that this is "redundant code" in the sense that developers shoudl not be informed about that?
Cheers,
Marcel
Marcel Bruch replied on Wed, 2010/09/08 - 9:41am
Hi
this post attracted quite a lot attention and it's overwhelming. But unfortunately this post came a few weeks too early: The prototype available for download currently supports JFace, Eclipse UI and SWT only but it does not support other frameworks yet. We are currently setting things up for large-scale use but are not done yet.
If you like to stay informed please consider to put yourself on the code-recommenders-announcements mailing list here: http://groups.google.com/group/code-recommenders-announcements
Sorry for not having the tool ready-to-use for all frameworks yet - but we will catch up soon ;)
kind regards,
Marcel
Jessie Mear replied on Wed, 2011/09/07 - 6:42am
Gar Labs replied on Sun, 2011/10/23 - 10:02am