Towards Dynamic Ides

The term "dynamic IDE" includes two aspects: The first aspect is to gather and present dynamic information about a software system directly in the IDE. In an dynamically-typed language where late binding is in use (eg. Smalltalk), it is only possible to entirely understand how a program is built by analyzing its dynamic behavior. The second aspect, or the second interpretation of the term 'dynamic IDE', is to adapt the IDE dynamically to the developer using it. If a developer for instance frequently browses class A followed by class C, why not presenting him : By dynamically analyzing a software system we could for instance detect different features of the system and detect the different source artifacts implementing these feature. By dynamically analyzing the work of a developer in the IDE, we can find out that he is working on a maintenance task for one or several specific features. Combining these different forms of dynamic "analysis" we could provide the developer with information specific to the task he is working on and hiding all other information not relevant to the task at hand.

To actually achieve the fore-mentioned visions we face several challenges:

This challenge is also partially covered by AdrianKuhn in his statement BridgeTheGapBetweenAnalysisAndIde. Besides the challenges mentioned in this statement, we see some others:

1. How to deal with the huge amount of information typically generated by dynamic analysis? How to select "useful" information? On what kind of information do we need to focus in an IDE?

2. How to present dynamic information in an IDE? Or more general, how to integrate information gained by software analysis or reverse engineering in an IDE to actually improve program comprehension, maintenance activities or navigation of source artifacts?

3. What kind of dynamic information is available at all or should be made available? Are higher level concepts such as locating features useful? Is it more promising to focus on lower level entities such as the dynamic receivers of a message send or the objects that have been stored in a instance variable? Or is it interesting to track single objects, eg. how they flow through the system?

These challenges are not only a matter of engineering and algorithms. To improve current approaches and concepts of IDE we have to focus on the developer. Eventually, he can judge best what kind of information is when useful for him and how it needs to be presented. This leads us to the next challenge:

4. How to validate and assess the usefulness of the newly presented information or of new integrated concepts to locate, navigate and work with source code artifcats? How to do empirical research in the context of IDEs? How to precisely assess an improvement, how to "measure" it?

5. How to analyze the working behavior of a developer? How to e.g. automatically detect the nature of the task the user is currently performing? How to anticipate what the developer wants to do next?

6. How to store the information generated by the user while he is working in the IDE? How to learn form this information to adapt the IDE dynamically, to eg. shorten long navigation paths between source artificats or to improve and straighten menus and interfaces?

7. How to deal with different developers using the same IDE? Can an IDE learn and adapt to only one user or can an IDE benefit when adapating to the needs of different users at the same time? Do different developers work in a similar way, do the have similar needs? Is an improving for one developer also an improving for another developer?

This challenge of course also contains the problem of validation.

8. How do dynamic analysis of a software system and the IDE usage of a developer interact? For what kind of situations is it useful to bring them together, to eg. further improve the IDE?

9. What would be a dynamic IDE eventually? What is more important, to have an IDE adapting itself dynamically to the needs of a developer, or is it enrich an IDE with dynamic information gained by analyzing of software? Are both things together most promising, or is only one needed/useful, and if so, which one?

10. Are other approaches to improve program comprehension, navigation of source artifacts and changing and evolving software systems in current IDEs more promising? Is it for instance useful to slightly improve the current tools to navigate source code, or is better to focus on new approaches to navigate source code, eg. approaches using dynamic information about a software system?

What is done so far?

In Squeak Smalltalk there is the ObjectFlow framework of Adrian Lienhard which allows us to gather dynamic information about message sends, object flows, etc. This framework is capable to gather all the required information. However, unsolved remains the problem of gathering this information while the developer is developing and adapting the application. Furthermore, there is the OmniBrowser IDE framework in Squeak, a flexible and extensible framework for building class browser and othere engineering tools. Our dynamic IDE could possibly be built on top of the OmniBrowser framework.

How to proceed?

The next steps will be to work on the techniques to gather the necessary dynamic information using the ObjectFlow framework. As soon this is done we can implement the presentation of the information directly in the IDE. Remaining steps are to validate the presentations we used (challenge A). Moreover, we plan to analyze how developers are using the IDE to reveal what are the current shortcomings and how we could improve them. This leads also to question how an IDE could adapt itself to the specific needs of a developer (challenge B). According to the results of these actions we then decide if and how to address challenge C.

An important, even crucial action is to experiment with our findings not only in Squeak, but also in wide-spread IDEs, especially Eclipse. This also includes the action to transform our results from a dynamic OO language (Smalltalk) to a static OO language (eg. Java).

  -- DavidRothlisberger


Last edited May 31, 2007
Return to WelcomeVisitors