← all entries

Fluid Frameworks

November 12, 2026

On New Year's Day 1968, Dick Morley, an engineer at Bedford Associates in Massachusetts, wrote a twelve-page memo describing a controller for factory machines that could be reprogrammed instead of rewired. By his own account he was getting over the night before. A prototype was running by March. It was the firm's eighty-fourth project, and the machine went to market as the Modicon 084.

What it replaced was the relay panel, a cabinet of electromechanical relays wired by hand to carry a machine's logic. Changing what the machine did meant pulling wire. The 084 kept the logic in memory, and it was programmed by drawing the picture an electrician already drew for a relay panel: two vertical rails, and between them rungs of contacts and coils. The relays were gone and the drawing stayed. Ladder diagram is still one of the five languages in IEC 61131-3, the standard for programmable controllers, and a great deal of the world's machinery runs on rungs.

The framework there was never the hardware. It was a notion in the electrician's head, and it survived a complete change of material.

Software frameworks spent the next forty years going the other way, turning notions into hard objects that got installed and depended on. With a language model writing the code, that is reversing. The coder's idea of a framework is getting softer in three steps: a template, then a notion assembled when needed, then a model.

Frozen decisions

In 1988 Ralph Johnson and Brian Foote gave the definition most programmers still work from. A framework is "a set of classes that embodies an abstract design for solutions to a family of related problems." They also named the thing that separates a framework from a library. The code a user writes to tailor a framework gets called by the framework, not the other way around, and "this inversion of control gives frameworks the power to serve as extensible skeletons."

In July 2005 David Heinemeier Hansson posted a screen recording of a weblog being built in Rails in fifteen minutes. The same month, Django came out of the newsroom of the Lawrence Journal-World in Kansas as open source. Both made the same offer. Where the routes go, how a request becomes a response, what a model is and how it reaches the database had all been decided already. Fifteen minutes was what it took to accept the decisions.

The freezing was the point. Those decisions were expensive to make and more expensive to implement, so it made sense to make them once and have thousands of projects depend on the same copy. It was reuse by shared code, because code was the costly part.

That cost has dropped. A model can write the routing, the login flow and the form handling in about the time it takes to describe them. What's scarce now is the decisions, and decisions don't have to ship as a dependency.

The post

Machine shops have worked with a looser kind of framework for decades. G-code was standardized as RS-274 in 1963, and the standard left enough open that every control maker filled it in differently. A Fanuc control, a Haas and LinuxCNC read programs that look alike and differ in ways that crash a tool. So CAM software doesn't emit G-code directly. It computes toolpaths and hands them to a post-processor, a file that says how this particular machine wants its moves, tool changes and canned cycles written.

A shop keeps a post for each machine and edits it. Nobody there thinks of the post as a dependency. It started as the vendor's generic file, and by now it carries every lesson that machine has taught.

That is a framework as a template, and software has been drifting toward it. A starter repository gets copied and owned. The shadcn/ui documentation opens with the line "This is not a component library," and what it hands over is source code to paste into a project and change. Nothing calls back, and there's no upstream version to stay compatible with.

This used to be a poor trade for anything large. A copy starts to rot the day it's made, and every fix is one you make alone. But owning code costs much less when something can read all of it and change it coherently on request. The post-processor model stops being a shop-floor habit and becomes a reasonable way to hold a whole application.

A million times over

The next step drops the template. In 1977 Christopher Alexander and his colleagues published A Pattern Language, 253 patterns for towns, buildings and rooms. Each one, they wrote, "describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice."

Programmers borrowed the idea in the 1990s and then mostly went back to shipping classes, because a pattern still had to be typed out by hand each time. That is no longer true. What gets carried from one project to the next can be a paragraph:

One motor, one encoder, one limit switch. A control loop at a fixed rate that nothing is allowed to block. A state machine that homes before it does anything else. Commands arrive on a queue and status goes out on another.

There's nothing in that to install. Given to a capable model it's enough to produce the skeleton, and to produce it differently each time. It can come out as an axis on a small mill or as the feed wheel on a ball machine for tennis practice, on one microcontroller or another, at the size the device needs. The framework is assembled when it's wanted, from the notion of it.

The conventions file at the root of a repository is the same thing from the other side. It tells whoever works on the code, person or model, what the shape is and why. An installed framework enforces its conventions through its interface. This kind enforces them by being read.

What the model already holds

On the Enterprise, Captain Picard walks up to a slot in the wall and says, "Tea. Earl Grey. Hot." That's the whole specification. The cup, the saucer, the amount, the water and everything else about what tea is are held by the machine. He states only what's his.

Go a step further and the paragraph gets shorter in the same way, because the model knows most of it already. It has seen how a request handler is laid out, how migrations are ordered, what a homing sequence looks like and why the loop mustn't block. Much of what a framework used to encode sits in the model as a general sense of how such systems fit together. The author supplies the differences, the parts of this project nobody would guess.

At that point "which framework are you using?" gets an odd answer. Some of it is in a package. Some is in a paragraph of prose. A good deal is in the weights of the thing writing the code.

Libraries, for a while

Johnson and Foote's distinction cuts between two things. A framework calls the user's code. A library is code the user calls. So far the models have let go of the first much faster than the second. Asked for a small web service, a model will lay out its own routing and structure, since it holds the skeleton itself, and then reach for a library to do the cryptography, talk to the database or compute a Fourier transform. The skeleton was made of decisions. The library is made of work somebody got right over years, and for a while that's the part still worth installing.

Even that will be penetrated. A library is shaped by not knowing its user. It carries a broad interface because its authors couldn't tell which tenth of it anyone would need, and a project takes on the whole thing to use a corner. A model can read the source, lift the two hundred lines this device calls for and write them in place, fitted to this processor. On a microcontroller with 32 kilobytes of flash that isn't a stunt. People have always done it by hand when the space was tight enough to justify the labor.

Behind that is a larger thing. So much of how we code was developed for human constraints. David Parnas argued in 1972 that a system should be cut into modules by what each one hides, so that a person could write one, or understand it, without holding the others in mind. Edsger Dijkstra's 1968 letter against the goto statement rested on a claim about people, that we follow the fixed text of a program far better than a process unfolding in time. Melvin Conway observed the same year that a system comes out shaped like the lines of communication in the organization that built it. The eighty-column line is the width of a punched card from 1928. The rule against repeating yourself exists because a person changes one copy and forgets the other. Morley's ladder was drawn that way for the electrician.

None of these is a law of computation. They are accommodations to a writer and reader with a small working memory, who tires, and who works in teams that have to split the job. A model has limits too, but they aren't those limits, and code written and read mostly by models will stop being cut to fit ours. Frameworks are going first because they're the largest piece of that accommodation. Libraries, modules and files are made of the same stuff.

The language itself

So are the languages. No machine ever needed one. A processor runs numbers, and everything above that was put there for people. John Backus's group at IBM delivered FORTRAN in 1957 so that a scientist could write something close to a formula. Grace Hopper built FLOW-MATIC out of English words because she expected people in business to read SUBTRACT more readily than a symbol. Harold Abelson and Gerald Sussman put it in one sentence in 1985: "programs must be written for people to read, and only incidentally for machines to execute." G-code is the same kind of thing. It's a notation a person could punch into tape and read back at the machine.

For a well-developed AI, the languages as they exist today have little meaning. Python against Rust, braces against indentation, the long wars over syntax, are all about what a human can hold, type and scan. A model that can go from a stated intent to a running machine has no stake in them. It writes Python now because the people who check its work read Python.

One part of a language may outlast its readers. A type checker or a compiler's proof that an index stays in bounds isn't there for reading. It's there to catch mistakes, and a model makes mistakes. What comes after may keep the checking and drop the notation.

That doesn't leave the traditional coder speaking plain English to the machine. Dijkstra saw that proposal coming and wrote a note against it in 1978, "On the foolishness of 'natural language programming.'" His case was that formal notation is what made precision possible in the first place, and that ordinary language lets a person say things that feel exact and aren't. He was right about ordinary language. Anyone who has asked a model for "a simple login" has found out how many decisions were in the word simple.

A new meta language will emerge, one level up from the languages, for coders to speak to the machine. It will be a language about programs. It says what shape is wanted, what must always hold, what may never happen, how fast, within what limits and how anyone would know.

Machine shops have had one for a long time. An engineering drawing doesn't tell a machinist how to cut anything. It gives the part, and the geometric tolerancing on it says in a small strict set of symbols how flat this face has to be and how true that bore has to run to it. The machinist chooses the setup, the tool and the order of cuts. Two shops will make the part two ways, and both parts will pass inspection. SQL made the same bargain in 1974 by stating what rows are wanted and leaving the how to the engine.

The pieces of the new language are lying around already, in conventions files, test suites, type signatures and the handful of terms a team settles on for its own shapes. They haven't been drawn together into one notation yet. When they are, it will be learned the way drawings are, and the people best placed to write it are the ones who know what a program is underneath.

Rules of order

Human groups run on frameworks too, and theirs have always come in all of these forms.

In 1863 Henry Martyn Robert, an Army engineer, was asked to preside over a church meeting in New Bedford, Massachusetts, and found he didn't know how. Posted later to San Francisco, he sat in meetings where people from different states each brought their own idea of how a meeting ran. In 1876 he published a pocket manual to settle it. Thousands of societies have since installed that manual the way a project installs a package. A line in the bylaws says the current edition of Robert's Rules of Order governs wherever the bylaws are silent. It's a dependency with version numbers, the twelfth edition having come out in 2020. It has inversion of control as well. Members write the motions, and the rules decide when a motion gets called.

The template form is just as familiar. A town rarely writes its own building code. It adopts a model code and amends it, and after twenty years the local copy is a shop's post, carrying what that town has learned. A new club starts from somebody else's bylaws with the names changed.

Most small groups run on a notion that nobody wrote down. A pickup basketball game has no referee and no rulebook at the court. Call your own fouls, winners stay on, and the rest is assembled on the spot by whoever showed up, a little differently at every court. Under that sits the model, a person's sense of how a fair game or a decent meeting goes, built from having been in a great many of them.

Groups reached for the frozen kind for the reason programmers did. Working out rules was expensive, so they borrowed someone else's whole. That cost is falling here too. A club of twelve can describe in a paragraph how its members want to decide things and get back bylaws that fit them, and can have them redrawn when the club changes.

What stays hard

Not everything should go soft, and machine control is where that's plainest.

Terminator 2 (1991) put the two kinds of frame on screen together. The older machine is built on a metal endoskeleton, Johnson and Foote's extensible skeleton with skin over it. The new one is liquid metal with no skeleton at all, and it takes the shape of whatever it has touched. The boy it's hunting asks whether it can turn itself into a bomb. It can't, the older machine tells him. It can make knives and stabbing weapons, solid shapes, but nothing with chemistry or moving parts. Anything with a mechanism in it still has to be built.

Some code is shared because the sharing is the value, and that will hold longest where a mistake is physical. A cryptography library, a database driver, a real-time kernel, the safety relay in an emergency-stop chain: the copy worth having is the one thousands of others have run and that gets fixed when a fault turns up. A generated one-off has nobody upstream. In a web application a wrong guess shows an error page. On a machine it breaks a cutter, or reaches a hand.

A framework is also a vocabulary. Two people who know the same one can read each other's work on the first day. Ladder has lasted nearly sixty years partly for that reason. An electrician called to a stopped line in the middle of the night can open the program and follow the rungs, and it doesn't matter who wrote them. If every codebase is assembled from its own description, that shared reading goes away unless the description is written down and kept true. Robert's trouble in San Francisco was the same one. Everyone in the room had a notion of how a meeting ran, and a meeting can't run on several at once.

And frozen decisions are a discipline. An installed framework says no, and so does a rule of order that a chair can point to. A fluid one will agree to anything, including a fourth, slightly different way of doing one job in one codebase, or bylaws redrawn to suit whoever asked last. Somebody still has to hold the shape, and that's harder when the walls move.

The drawing stays

Morley's controller got rid of the relays and kept the electrician's drawing, and the drawing turned out to be the part that mattered. Something like that is happening to software frameworks. The classes and the installed skeleton were one way of keeping a set of decisions, a good one while code was expensive to write. The decisions can now be kept as a file a team owns, or a paragraph, or a model's sense of how things go.

That moves the work from choosing a framework to stating one. A coder has to know what shape is wanted, say it precisely enough that it can be built, in whatever the drawing-language of programs turns out to be, and recognize whether what comes back is that shape. The human constraints don't all go, either. For as long as a person is the one called on the night the line stops, somebody has to be able to read the rungs.


Sources: Ralph E. Johnson and Brian Foote, "Designing Reusable Classes", Journal of Object-Oriented Programming 1, no. 2 (June/July 1988); Control Engineering, "How Programmable Logic Controllers Emerged from Industry Needs"; Automation.com, "The Dawn of the Programmable Logic Controller"; IEC 61131-3, Programmable controllers, Part 3: Programming languages (first edition 1993); John Gruber, link to the Rails weblog movie, Daring Fireball (8 July 2005); EIA RS-274-D (1979) and ISO 6983 (1982); CNCCookbook, "G-Code Dialects"; shadcn/ui documentation; Christopher Alexander, Sara Ishikawa and Murray Silverstein, A Pattern Language (1977); D. L. Parnas, "On the Criteria To Be Used in Decomposing Systems into Modules," Communications of the ACM 15, no. 12 (1972); Edsger W. Dijkstra, "Go To Statement Considered Harmful," Communications of the ACM 11, no. 3 (1968); Melvin E. Conway, "How Do Committees Invent?" Datamation (April 1968); Harold Abelson and Gerald Jay Sussman, Structure and Interpretation of Computer Programs (1985), preface; Edsger W. Dijkstra, "On the foolishness of 'natural language programming,'" EWD 667 (1978); ASME Y14.5, Dimensioning and Tolerancing; Donald D. Chamberlin and Raymond F. Boyce, "SEQUEL: A Structured English Query Language" (1974); Henry M. Robert, Pocket Manual of Rules of Order for Deliberative Assemblies (1876), and Robert's Rules of Order Newly Revised, 12th ed. (2020); Star Trek: The Next Generation (1987–94); James Cameron, dir., Terminator 2: Judgment Day (1991).


A note on how this piece was written: the subject and the three steps, template, assembled notion and model, are mine, as are the point that libraries will follow frameworks because so much of coding practice was built for human constraints, that today's computer languages mean little to a well-developed AI, that a new meta language will emerge for coders to speak to the machine, and carrying the idea over to the frameworks human groups use. The examples, the research and the sentences were drafted by an AI model working from that direction. I'd rather say that plainly than have a reader guess at it.