HackerWith old users still here, how far can a new version change?
A required field, an old web page, a Soviet computer: once a version has users, every change must say who migrates and who carries the old behaviour.
Questions in this reading · 8
- Is starting the old program enough for compatibility?
- Who migrates when a field becomes mandatory?
- What obligation can one old web page create?
- Who pays for the next update to custom software?
- Who must keep up after a compatibility decision?
- Should a menu describe its role or command all input?
- Can successors still maintain the hidden implementation?
- How can others combine modules in ways their authors never planned?
Is starting the old program enough for compatibility?
Rename a field in a message and the producing service may still compile. Hickey points out that names crossing a process boundary have other readers. Goetz distinguishes linking an old binary, recompiling old source and preserving behavior at runtime. Keep an old artifact, old source and an old message, then exercise them separately. Each tests a different promise.
Passages and timestamps · 2
as your names start escaping out of your processes, that they are global namesexisting class files will continue to linkWho migrates when a field becomes mandatory?
In Hickey’s terms, a mandatory field raises the caller’s obligations. Winters’s diamond dependencies explain why two teams may not move together: each reaches a shared component through a different intermediary. Wright supplies a migration order: offer the replacement while retaining the old default, move callers in batches, then end the transition. A version number can identify the two interfaces but cannot supply the missing data for an unmigrated caller.
Passages and timestamps · 3
if you require more than somebody who's giving less now is not going to get what they wantIf everyone in your infrastructure doesn't upgrade at the same time, then we have version skew.Usually you add the new thing without making it the default.What obligation can one old web page create?
Eich explains why early JavaScript choices survived: other people had shipped pages that used them. Van Rossum recalls a different route, fitting information for an external checker into existing Python syntax. Lattner presents gradual type adoption as a Mojo design goal. Take an old unannotated function and ask three questions. Must its result stay the same? Which tool reads the new information? Can an unmigrated caller still use it? The compatibility obligations differ across the three projects.
Passages and timestamps · 4
the force of web compatibility meant early mistakes couldn't be fixeda compromise syntaxuse that existing dummy syntaxprogressively adopt types into your programWho pays for the next update to custom software?
Customizing a package for one Japanese customer's workflow could win a contract without producing something another customer could immediately adopt. Fragmented platforms also spread update work across implementations. Alongside the initial contract, track who maintains the differences and which tested behavior a second customer can inherit.
Passages and timestamps · 2
modified for customers' existing business practicesthere was no widely accepted platform or operating systemWho must keep up after a compatibility decision?
In the Soviet planning history, compatibility with existing software, access to programming methods and time to delivery could favor different options. Follow compatibility over one update: can a current program run, which documentation and skills are needed for the next release, and which supplier must act? That turns a checkbox into a maintenance obligation.
Passages and timestamps · 2
compatibility, learn British programming methodspush back the project's delivery dateShould a menu describe its role or command all input?
Stone adds a concrete test to an interface contract. When a menu opens, does the application say “this is a popup triggered by this click,” or demand all input and a fixed window position? In his 2013 account, conflicts involving volume keys and screensavers show how the latter agreement spreads a local need across the desktop. Device enumeration provides a second example of the boundary: using the same event format for current devices and later hotplug notifications lets callers use the same handling logic. For your own interface, list the intent the caller actually knows and the actions that belong with whoever coordinates global state. That reveals more about responsibility than counting parameters.
Passages and timestamps · 2
Wayland is also descriptive, not prescriptive.these are all the current devices in the same formatCan successors still maintain the hidden implementation?
Blow adds a maintenance question to hiding implementation: can the complexity mastered by one person today also be passed to whoever takes over? His concern need not require every caller to understand all lower-level details. It asks what happens when troubleshooting habits become common knowledge while fewer people understand the mechanism. For a module, record its interface promises, who can explain the implementation, and how to test maintainability after a handover. This is a reading exercise drawn from the talk, not evidence that a particular tool or the entire industry must decline. Carry the answer from the final questions along with it: problems can be inherently difficult, and removing added complications does not guarantee complete understanding by everyone.
Passages and timestamps · 2
the amount of complexity we can sustain over timewhether that's good enough I don't knowHow can others combine modules in ways their authors never planned?
Ken Thompson recalls how Unix pipes let people connect programs that had worked independently. To make a sorting tool work as a filter, its output had to shed chatter such as progress messages so the next program could use it directly. Stefan Karpinski describes another way to build on existing code in Julia. A downstream package can define new methods for an existing type while other packages continue to use the same type. The first example makes data passed between programs the point of connection. The second uses a shared type and methods that packages can add. What must stay stable for downstream developers to make the extension in their own code?
Passages and timestamps · 2
interconnections of things that were never meant to be in the same room togethercan define methods outside of the type later onTry it on your own example
Pick an interface you want to change. List who still relies on the old behaviour, then write down who pays for the migration.