The Evolution of Code Editors

In the world of programming, the tools we use have always played a pivotal role. They can make you win or fail. Code editors, in particular, have seen a fascinating evolution over the decades. This post goes through a brief history of editors.

Let's first start with punch cards. Although not a text editor as we know them today it is one of the first techonologies that made possible writing a custom program for a computer. They predate computing and they where the preffered way of writing programs in the 1950s. Remember back then having "programmable" computers was not a given, but a novelty (ENIAC on 1945 for example). These programmable computers implemented any input method like punch cards, paper tape, plug boards, magnetic drums or more.

Quick detour: To write this I watched this video on punch cards from computerphile which blew me away. I can't believe you wrote actual programs on those paper things. Imagine the meticulousness and patience that requires. Imagine not having a file system where you could have your own file but having to manually write a PREVIOUS program to input data to some address on the copmuter. Just unimaginable today. At least they had ALGOL for the cards on the video

With the rise of programmability, languages were born. This way programmers could input programs written directly on these instead of assembly to the computers. In the computerphile video, the computer for whose the punch cards were made supported ALGOL. A simple factorial calculator could be written like this in ALGOL:

begin
    integer procedure factorial(n);
    value n;
    integer n;
    begin
        if n = 0 then
            factorial := 1
        else
            factorial := n * factorial(n - 1)
    end;
    
    integer result;
    result := factorial(5);
    outinteger(1, result)
end

Instead of this in assembly.

* IBM 704 Assembly - Factorial Program
        ORIG    200
START   STZ     FACT           / Initialize factorial result to 0
        LDA     NUM            / Load the number into the accumulator
LOOP    CPZ                    / Compare accumulator with 0
        TNZ     DONE           / If zero, jump to DONE
        MPR     FACT           / Multiply accumulator with FACT
        STO     FACT           / Store result in FACT
        TRA     LOOP           / Repeat
DONE    HLT                    / Halt the program
NUM     DEC     5              / Number to calculate factorial of
FACT    DEC     1              / Initial factorial value
        END     START

As technology progressed, the rise of text-based editors came into play. Vi and Emacs emerged as the champions of this era. They were powerful, but with power came complexity. Mastery of these tools was seen as a hallmark of a seasoned programmer. These editors didn't offer the graphical interfaces we're accustomed to today, but they provided more flexibility and efficiency than punch cards. Syntax highlighting, search and replace and UI customization are some of the notable things they brought with them. Paving the road for the modern editors we know now.

The 2000s saw the emergence of Integrated Development Environments (IDEs) like Eclipse, NetBeans, and Microsoft's Visual Studio. They transformed the developer experience by integrating various aspects of software development into a single interface. With built-in debuggers, compilers, and a plethora of plugins, these IDEs represented a significant leap in programming efficiency. Havnig all in one place was the trend.

In more recent times, the spotlight has shifted to lightweight, efficient editors that combine the best of both worlds. Sublime Text set the stage with its sleek interface and performance. It stripped away unnecessary complexities and focused on delivering a smooth coding experience.

But the evolution didn't stop there. Visual Studio Code (VS Code) came onto the scene, blending the simplicity and speed of tools like Sublime with the extensibility traditionally found in full-fledged IDEs. With a thriving community and a vast extension marketplace, VS Code epitomized the modern code editor's potential. Today it wins because it is seen as the sweet spot between performance, extensibility and IDE-like features.

As always, the future is bright. New developments like cloud based editors or AI editors are in the way. Visual Studio code for the web promises accessibility, a consistent environment, cloud native integrations and more. Cursor.so on the other hand stands out as a Vscode fork completely focused on making developers work in symfony with AI agents. If you haven't tried Cursor I really recommend it, not as fast as Vscode but still a nice experiment.

Looking back at this journey, it's clear that the history of code editors is a reflection of the broader evolution in software development. As our needs and challenges have changed, so have our tools. And as the digital age continues to advance, one can only anticipate the innovations that lie ahead in the world of code editing.