Published: 2022-05-14

Ideas for a better IDE

I have often complained about the lack of good modern tooling for systems development. I finally decided to sit down and write up a collection of ideas and concepts I wish someone would steal and develop into a fully fledged modern integrated development environment.

Some of these concepts are well fleshed out, others are very rough and not well thought through. Some of these concepts can be achieved by using existing external tooling, or by overriding various IDE features like comments and highlighting to obtain partial functionality. Some ideas overlap with others, and some may even be mutually exclusive. Some may find a better home inside language tooling as opposed to a vanilla IDE implementation. Some are probably bad ideas.

Regardless they are all things I have thought about at one time or another, and I would love to see people experimenting with them.

Annotations or Multi-level Comments

Between comments, FIXMEs, TODOs and git blame there is a collection of information about a piece of code which lives mostly in code reviews, external discussions and whiteboards. A kind of continually in-progress code review.

Additionally, some comments need to expand beyond an immediate line or function. Capturing some coupling or dependency that cannot be fixed immediately, but that is known about and might one day be resolved.

I would love a feature in my IDE that allowed me to link comments together or annotate a collection of functions or types or structures with higher level information that can be contextually displayed.

Inline Proofs

Some code lends itself very nicely to being proven correct, rather than simply asserted correct through tests. I’ve played before with embedding proofs in comments (and Rusts proc macros) but it would be really nice to have an IDE that expects this information and surfaces it.

Tainted Types / Functions

Occasionally I would love to be able to mark up a type or function as providing untrusted data and have visualize indicators of how that data moves through the system.

Inversely I would like to have a set of functions or types marked as neutralizes that could act a sinks for tainted data - thus have a clean separation between safe and unsafe data flows flows and clear indications of what functions require particularly robust testing and formalizing.

Test Counterexample Generation

Given a function, and a set of desired properties, generate a set of inputs which violate the given properties.

Model Building

Where code is designed to implement (part of) a larger system model, I would love to be able to embed the model within the IDE and tie parts of the code directly to parts of the model.

Requirements Tracking and Analysis

A way of encapsulating everything about the system together so they can be treated as a whole.

• I need the system do to A
• Here is the code that implements A
• Here is the code that tests A
• Here is the proof that A is correct

In the past I have used plugins for a few proprietary systems that do surface requirements from other systems into the IDE itself, but rarely anything beyond that kind of visual clutter.

Embedded References

Sometimes people inside and outside of academia have good ideas and write them down. These primary source materials are full of great context, explicit warnings, additional requirements and assumptions about an algorithm that is being implemented. Being able to capture this information and have it available within the IDE as documentation or additional reading would be very useful both the people implementing ideas from the paper and to eventual end-users of that implementation.

Function Visualizations

When dealing with pure functions with a fixed input and out domain it is often useful to visualize the function itself. We can extend this to the composition of pure functions.

Visual Compute Graphs

A quick way of examining how a particular function fits within the larger system, where is called from, what does it call, if it spin off any threads etc.

All this information is readily available, but higher level visualizations tend to require external tooling.

Quick Test Views

Depending on the language the tests that are relevant to the current piece of code you are working on might be in the same file, in the comments, or in a completely different file, perhaps even in a different folder hierarchy.

I often find there is a resistance between the active code and related tests - for long tasks this can be overcome with a deliberate split-screen setup, but this quickly become laborious for many tasks.

I would love if I could hit a button or key combination and the IDE would present everything relevant to the current function in a standard view.

Cross-System Views

I very often work on code that transcends package boundaries e.g. while working on performance optimizations I might find that I can correct a slow down in library A by fixing a flaw in library B - at the same time I might be working in library A for the sole purpose of implementing a new feature in application C.

My options for keeping track of all this work are pretty limited - short of invoking a monorepo - I either have to curate custom workspaces which very quickly become out of date, or I live with 30 different IDE windows open.

What I would really like is an alternative to “projects” or “workspaces” that understands that people often work on many different systems at the same time, sometimes in isolation and occasionally in tandem. Growing interaction instead of enforcing strict hierarchies.

Transparent Constants

Many systems adopt a good practice of defining constants as variables e.g. timeouts or memory addresses or magic numbers. This make reading code much easier to understand on a casual read through.

Many editors allow moving the cursor over these variables to resolve them but I sometimes find myself wanting to quickly toggle these variables off to see the raw value of all of them at a glance - either as a quick soundness check or a more thorough review.

Exposing State

Especially in the context of legacy systems, structures can end up with fairly complex acquired state. Through static analysis it is often possible to at the very least understand what states are probable, what state are possible and what states are impossible. This can lead to identifying simplifications, reducing abstractions and improving security and performance.

Visualize Markdown-Diagrams

There are now numerous markdown-enabled diagramming languages that can be embedded on websites (or visualizing in READMEs) - there is no reason that these could not come alive in editors also. (There are plugins to add this functionality to the markdown preview in editors, but I am talking about adding these visuals directly into the editor.

Dependency Cutout

Sometimes there is a library that does exactly what you need but also much much more. Sometimes there is a library that does almost everything you need, but is unmaintained or not accepting PRs in the direction you want to modify it.

In these circumstances the best option is to cut out the behavior you want and bring it into your system. It would be really nice to have an IDE that understood this flow.

Integrated Framebuffer

Many of the small projects I work on rely on simple graphics output via a framebuffer. Often I leave one version of the application running while I ponder what to work on next - it would be awesome if that view could be easily integrated into the development environment to avoid window switching.

This is also a feature I feel could expand beyond this initial application e.g. displaying stats or output from elsewhere to monitor systems while building them.

I’m sure there are more ideas than just these locked away in my head, but these are the ones that came to me this morning. If you do end up stealing one of these ideas and implementing an awesome IDE then please get in touch!

Queue someone telling me how emacs does all of this already.