I've been a zone leader with DZone since 2008, and I'm crazy about community. Every day I get to work with the best that JavaScript, HTML5, Android and iOS has to offer, creating apps that truly make at difference, as principal front-end architect at Avego. James is a DZone Zone Leader and has posted 639 posts at DZone. You can read more from them at their website. View Full User Profile

IDE 2.0: The Age of Intelligent IDEs

  • submit to reddit

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.



Loren Kratzke replied on Thu, 2010/09/02 - 12:01pm

Not to sound like a parrot but - Netbeans, out of the box. Unless I am missing something, their quick demo on their home page simply narrows the completion choices to those which return void, the only "logical" choices given that the user is not making an assignment. Sigh...

Chris Roberts replied on Thu, 2010/09/02 - 1:42pm in response to: Loren Kratzke

I think this is a little more involved than that, though -- what they're doing is actually looking at your past usage patterns to determine which methods you're likely to use based on previous behavior, and in some cases (I believe in their SWT demos) they're even going outside of your particular usage patterns and comparing methods with what, historically, most people use in similar coding situations.  From the demo I've seen, and from previous write-ups elsewhere, they use some pretty complex heuristics and not just simple tests like "is there an assignment in the statement?".  It reminds me of what Mylyn is already doing (easing your workflow based on "watching" you work), but at a different level.

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.


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,


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: Marcel Bruch

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: Loren Kratzke

LOL. OK, I take away:To blow your hair back, we have to:

  1. showcase other frameworks than Eclipse UI, 
  2. don't couple "IDE 2.0" too strong with Eclipse,
  3. provide means to build company internal knowledge repositories.

(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 Bruch replied on Tue, 2010/09/07 - 1:22am in response to: Jason Marshall

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?





Marcel Bruch replied on Wed, 2010/09/08 - 9:41am


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,

Jessie Mear replied on Wed, 2011/09/07 - 6:42am

Version 2.0, the Fuse IDE (an Eclipse plugin) builds on a visual environment that enables developers to "drag-and-drop" the integration and mediation components needed to connect several systems and applications. java programmers

Gar Labs replied on Sun, 2011/10/23 - 10:02am

IDE (Integrated Development Environment) is particularly important to programs for their software development. This is high level computer stuff. I guess with the new development of IDEs, programmers will truly embrace it with open arms. - GAR Labs

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.