To actually achieve the fore-mentioned visions we face several challenges:
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?
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.
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).