Why build yet another IDE?

There is a fundamental aspect of software development that has remained essentially the same for decades - the text editor. With rare exceptions, a program today is typically just a collection of source files modified using a text editor. The same text is used when writing, reading and storing a program on disk. The reasons for this are mostly historical, with this being the only possibility in the early days of computing. Nowadays however the absolute coupling of these three activities is no longer necessary. Envision features a Model-View-Controller architecture that clearly separates program storage, analysis, comprehension and modification and allows for their optimization.

While there have been many attempts to introduce structured and visual editors in the past, none of them were successful in the context of general-purpose large-scale development. Envision is specifically designed with professional software engineers in mind and strives to offer flexible visualizations and powerful interaction mechanisms that will boost productivity.

What are the main goals and fundamental concepts of the project?

Envision is an IDE and an information system. A core principle of the platform is the separation of concerns of reading, modifying, analyzing, and storing programs.

The application tree is the central data structure that defines an application. It has no inherent representation, neither textual nor visual. The tree is similar to the abstract syntax tree of a programming language but is more than just that. Here are the main features that Envision's tree will offer:

Rich content - the application tree can contain not only the program structure but also software engineering artifacts such as comments, images, tables, documentation, graphs, plans, schedules, etc.
Content linking - information from different parts of the system can be linked to ease navigation and maintain consistency. For example, values of program constants can be derived from values which appear in the documentation of the project.
Semantic and fine-grained version control - version control can be performed for logical objects such as classes or methods as opposed to files. This will make it easier to track the evolution of the program and even find version related bugs.
Flexible and implicit persistence - projects can be automatically persisted on disk, in a database or in a different way defined by the programmer. It is no longer necessary to manually structure files on disk and programmers can focus on the logical structure of the application they are developing.
Language independent application tree - Envision's tree is based on programming concepts and not on the features of a particular programming language. Programmers use Envision to create an application using these concepts. Concepts for example are classes, inheritance, dynamic dispatch, static methods, constants, operators, generics and many other commonly found features in modern programming languages. Such a tree can then be translated to any programming language's syntax as needed. This has the advantage that many tools can be created to operate on the generic tree and their results will then automatically apply to a wider range of programming languages. This includes tools for refactoring, analysis, visualization and others. Naturally it will still be possible to parametrize such a tool with a specific target programming language when this is essential for the tool's operation (for example profiling and optimization tools).

The View is a particular way to visualize the application tree to the user. A view may display the entire tree or part of it. It can display a segment of the program in complete detail or it can show a summary of the more important features of that part. The view can consist of text, visual elements and any combination of the two. Some of the key features of this approach are:

Rich and flexible visuals - programs are represented as a mixture of textual and visual elements and are not limited to text files. It is possible to display images, tables, animations or other artifacts in the same view as the program fragments that they refer to.
Analysis overlays - it is possible to present the results of various types of analyses as an overlay directly on top of the program segment they refer to. This could be used for example to highlight errors found by a type system or a verifier, to indicate which branches of a method have not been covered by test cases, show values of variables during debugging and others.
Multiple views - a tree may have many associated views which visualize it in a number of ways suitable for different tasks.
Visual cognitive processing - programming constructs are rendered visually using lines, colors, icons, and positions. Such visual elements are processed faster in the human brain compared to text and are remembered longer.
Spatial navigation - a program can be navigated in a two dimensional canvas to improve developer orientation and focus. For example, instead of switching between multiple tabs, a programmer can simply put all relevant pieces of the program next to each other for a better overview.
Semantic zoom - the developer can zoom in and out to observe the application at different levels of detail. This is especially helpful when one is exploring an unfamiliar program as it makes it possible to quickly gain an overview of the entire project and selectively see more detail about a particular part by zooming in on it.

The Controller is the mechanism by which the application tree can be modified. Unlike conventional IDEs where programmers directly modify the structure of the program by writing text, in Envision they rely on the aid of the controller to do this more efficiently. Some key ideas of this approach are:

Relaxed or no syntax - Since Envision features a structured editor there is no complicated syntax to deal with. To enable keyboard interaction developers still need to know some commands but these are simple and intuitive.
Direct manipulation - programmers can interact in a natural way directly with the visual objects that represent a segment of the tree. This helps preserve focus, which could otherwise be lost, for example if the developer needs to go through a series of menus to perform a task.
Keyboard centric interaction - while keyboard input is standard for traditional text-based programming, many visual programming systems are centered on mouse interactions. Unlike these systems, Envision focuses heavily on keyboard input and uses the mouse to complement it. We believe that in the hands of an experienced developer, the keyboard is a very effective input mechanism and provides for better productivity compared to mouse based interactions.
Command based interaction - one way to modify the tree or invoke IDE functions is via textual commands. The commands are context sensitive and are applied to the currently selected item. This enables a powerful interaction mechanism with the IDE that is similar to an operating system's terminal.

A pervasive feature throughout Envision's design is extensibility. The system supports extensions that can add new functionality to all of its core elements. This enables experimentation with different settings and features so that the platform can be fine-tuned and productivity maximized.