Delphi

Delphi is a rapid application development environment created by Borland in 1995, designed by Anders Hejlsberg, built on Object Pascal, and responsible for the single most prophetic idea in the history of software development: the component.

A Delphi component — TComponent, the base class — was a typed object that knew how to render itself, handle its own events, configure itself at instantiation, and compose with other components through a visual designer or through code. Properties and event handlers on the same object. State and behaviour, together. A struct with methods that does the thing.

The industry spent the next thirty years reinventing this idea in increasingly complex forms — JavaBeans, .NET controls, React components, Vue components, Svelte components, Web Components — each reinvention adding abstraction layers, build systems, virtual DOMs, state management libraries, and npm dependencies, and each one arriving, after enormous effort, at approximately the same place Delphi started: a thing that renders itself and handles its own events.

“We spent 30 years building React and Redux and Flux and hooks and signals and stores… to arrive back at Object Pascal patterns with extra steps.”
— riclib, Raiders of the Lost Architecture A V3 Origin Story

TComponent

The genius of TComponent was not technical sophistication. The genius was technical sufficiency.

A component had properties — typed, inspectable, serialisable. A component had events — OnClick, OnChange, OnResize — which were method pointers, which were type-safe callbacks. A component had a parent, which handled layout. A component had an owner, which handled lifecycle (when the owner was destroyed, the component was destroyed). A component could render itself in a visual designer and in code, identically, because the visual designer was not a separate abstraction but a direct manipulation of the same object the code manipulated.

Drop a TButton on a TForm. Double-click it. Write the handler. Press F9. The application runs. The compiled binary is 1.2 MB. It has no dependencies. It runs on any Windows machine from Windows 95 to Windows 11. It will still run in 2056.

Compare this to the modern web component:

1. npm init
2. Install React (47 MB of node_modules)
3. Install a bundler (Webpack, Vite, esbuild — choose, but choose wrong and start over)
4. Write JSX (which is not JavaScript but compiles to JavaScript through a build step)
5. Manage state (useState, useReducer, Redux, Zustand, Jotai — choose, but the choice defines your architecture)
6. Handle events (synthetic events, not real events, because React interposes a virtual DOM)
7. Build (transpile, bundle, tree-shake, minify, source-map)
8. Deploy (to a server that serves static files to a browser that interprets JavaScript to render HTML that could have been served directly)

The result: a button that does something when you click it.

TComponent did this in 1995 with zero build steps, zero dependencies, and a binary that ran until you stopped it. The binary is probably still running somewhere, on a machine in a Portuguese logistics company, faithfully processing invoices, unaware that the framework it was built with has been declared dead by people who have never achieved its reliability.

Anders Hejlsberg

Anders Hejlsberg is the most important programming language designer that most programmers cannot name.

Turbo Pascal (1983) — Hejlsberg wrote the compiler. The fastest Pascal compiler in existence. It compiled faster than developers could type. It was Borland’s first product and it made Borland.

Delphi (1995) — Hejlsberg designed the language and the component model. Object Pascal with visual design, RAD development, and native compilation. It was the best way to build Windows applications, and it was Borland’s peak.

C# (2000) — Microsoft hired Hejlsberg away from Borland. He designed C#, which was, depending on your perspective, either “Java done right” or “Delphi for .NET.” The properties, the events, the component model — C# carried Delphi’s DNA into Microsoft’s ecosystem. Microsoft had to buy the architect because they couldn’t beat the architecture.

TypeScript (2012) — Hejlsberg again. JavaScript, but typed. The language that made the web bearable for anyone who had ever used a compiled language. TypeScript is what happens when the person who designed Turbo Pascal looks at JavaScript and says “no.”

Four languages. Four decades. Each one an answer to the same question: how do you make programming sufficiently powerful without making it unnecessarily complex? Each answer was essentially the same: types, components, native compilation where possible, and the minimum ceremony required to get from intent to working software.

The industry followed a different path each time. It chose Java over Delphi. It chose JavaScript over TypeScript (until TypeScript became unavoidable). It chose complexity over sufficiency, frameworks over components, abstraction over directness. And each time, after a decade of wandering, it arrived at the place Hejlsberg had already been.

The V3 Revelation

The lifelog records the moment when Delphi’s ghost reappeared, thirty years later, in a Go codebase:

type ToolEditor struct {
    ID string
}
func (t ToolEditor) Render() templ.Component
func (t ToolEditor) HandleSave(w, r)

A struct that knows how to render itself and handle its own events. Configure at instantiation. Same logic, different data.

This is TComponent. In Go. In 2025. After thirty years of JavaBeans, Spring MVC, React, Redux, Flux, hooks, signals, stores, and every other reinvention of the component concept. The industry walked in a thirty-year circle and arrived at a Go struct with methods, which is a TComponent with different syntax, which is the answer that Anders Hejlsberg gave in 1995 to a question the industry hadn’t asked yet.

“The junior dev in me wanted a framework. The senior dev in me designed slot registries. The mass in me remembered Delphi and simplified everything.”
— riclib, Raiders of the Lost Architecture A V3 Origin Story

Why It Lost

Delphi lost for three reasons, none of which were technical:

Timing. Delphi shipped in February 1995. Java shipped in May 1995. Java had “write once, run anywhere.” Delphi had “write once, run on Windows.” In 1995, Windows was 90% of the market and “run anywhere” was a theoretical advantage. By 2000, the web existed, the server mattered, and “run anywhere” meant “run on the server,” which Java did and Delphi did not, not because Pascal couldn’t run on a server but because Borland didn’t build the server story.

Marketing. Sun Microsystems spent hundreds of millions of dollars marketing Java. Borland spent what Borland could afford, which was less. Java became a brand. Delphi remained a tool. Brands win markets. Tools win work. Markets are larger.

Microsoft. Microsoft hired Anders Hejlsberg, created C#, created .NET, and built Visual Studio — which was, functionally, Delphi for .NET, with Microsoft’s marketing budget and Microsoft’s platform lock-in. Delphi’s users migrated to C# because C# was Delphi’s ideas with a Fortune 500 company behind them. Microsoft didn’t beat Delphi. Microsoft absorbed Delphi, digested it, and presented it as innovation.

Borland survived until it didn’t. The Delphi product was sold to Embarcadero, then to Idera, each acquisition reducing the user base and the investment. Delphi still exists. It still compiles native binaries. It still has components. It still works. It just doesn’t matter, in the way that the first person to discover a continent doesn’t matter once the second person names it.

The Delphi Pattern

The Delphi Pattern is the phenomenon whereby a technology solves a problem correctly but too early, is ignored, and is then reinvented — poorly — every five years until the industry arrives at the original solution and declares it novel.

Examples:

The rightmost column measures what each reinvention added beyond what Delphi had. In most cases, the answer is “complexity.” In Go’s case, the answer is “nothing,” which is why the Go struct with methods felt like coming home.

The Lizard’s Observation

The Lizard, shown a TComponent from 1995 and a Go templ component from 2025, blinked once and produced a scroll of unusual precision:

THE COMPONENT RENDERS ITSELF
THE COMPONENT HANDLES ITS EVENTS
THE COMPONENT KNOWS ITS LIFECYCLE

THIS WAS KNOWN
THIS WAS KNOWN IN 1995
THIS WAS KNOWN IN OBJECT PASCAL

THE INDUSTRY FORGOT
THE INDUSTRY REINVENTED
THE INDUSTRY REINVENTED THIRTY TIMES
EACH TIME WITH MORE STEPS

THE STRUCT HAS METHODS
THE METHODS DO THE THING
THE THING WAS ALWAYS THE THING

ANDERS KNEW

See Also

• Java
• Go
• Design Patterns
• Rewrite
• YAGNI
• Boring Technology
• The Caffeinated Squirrel
• The Lizard
• Raiders of the Lost Architecture A V3 Origin Story