IDE Toolkit

Room 4 of six

The Inventions

Ideas that had to be named before they could be built — syntax highlighting, the breakpoint, IntelliSense, refactoring, the Language Server Protocol.

7 piecesAll six rooms

A debugger paused at a breakpoint in an early 1990s IDE, showing the highlighted line, a watch window with variable values, and the call stack panel beside it

Cassettes, labelled by hand.

Photo: CARTIST . / Pexels

  • Man viewed from behind coding at dual monitors displaying colored syntax-highlighted text in a dark room

    The Colour Came Later Than You Think

    Syntax highlighting is now assumed in any editor, but its adoption in mainstream IDEs was gradual and contested — early terminals could not do it, and some developers actively opposed it. This piece traces the idea from its roots in hardware character attributes through its arrival in Turbo Pascal and into the colour schemes of modern editors.

  • Pascal code editor showing a program called setop with set operations on weekdays

    The Program Stopped, and the Guess Ended

    The integrated debugger — specifically the breakpoint that halted execution inside the editor — changed what debugging meant for developers who had previously worked from printouts and log files. This piece follows the breakpoint from its early mainframe forms through its arrival in Turbo Pascal 5.0 in 1989 and into the watch window of Visual Studio.

  • A person types on a keyboard facing two glowing monitors displaying lines of code in a dim room

    IntelliSense, 1996 — the Dropdown That Changed the Argument

    Microsoft introduced IntelliSense in Visual Studio 97 (shipped 1996) as a dropdown list of completions drawn from the live type system. This piece examines the feature's original implementation, the engineering behind parsing a partial expression mid-keystroke, and why autocompletion became the capability every subsequent IDE was measured by.

  • Bearded man in a tweed blazer and pink shirt smiling against a concrete wall

    Refactoring as a Named Operation

    Martin Fowler's 1999 book named refactoring as a catalogue of discrete, safe transformations — and IntelliJ IDEA arrived in 2001 with rename, extract method and move class implemented as first-class menu items. This piece covers Fowler's catalogue, Sergey Dmitriev's argument for tool-assisted refactoring, and what it meant to have the IDE hold the edit rather than the developer.

  • Two silhouetted workers face computer monitors below a large screen showing a flowchart diagram

    One Protocol, Every Language

    Microsoft published the Language Server Protocol in 2016 alongside Visual Studio Code — a JSON-RPC contract that separated language intelligence from the editor, so a single language server could serve any editor that implemented the protocol. This piece examines the problem it solved, the architecture it introduced, and what it changed for tool authors who had previously written editor-specific plugins.

  • Programmers work at dual-monitor computer stations displaying code in a dimly lit office

    When the Diff Moved Inside the Editor

    Version control integration — showing a diff, staging a hunk, reading blame inline — moved from the command line into the editor gutter over the course of the 2000s. This piece traces the integration from CVS plugins in Eclipse through the Git adoption that made the editor the primary interface for a commit.

  • Two monitors and a laptop display code editors in a dimly lit workspace at night

    The Marketplace Made the Editor a Platform

    Eclipse's plugin architecture (2001) established the pattern; the VS Code Marketplace (2015) scaled it to millions of installs and made extensibility the primary argument for choosing an editor. This piece examines the plugin manifest, the extension API surface, and how the marketplace model changed the relationship between an editor and the languages it supports.

The other rooms