What Each Era of Software Has Taught Us

The software industry periodically announces that computing has changed forever. This is often true, although the person making the announcement rarely mentions how much of the previous arrangement will remain underneath it.

A modern application can involve a browser, a remote server, several borrowed libraries and a system old enough to have opinions about decimal currency. On the surface, everything is seamless. Somewhere below, a scheduled process is moving a file because nobody is entirely sure what would happen if it stopped.

Software history is not a procession of obsolete ideas being replaced by correct ones. It is a series of bargains. Each era removes a difficulty, creates a dependency and leaves the next generation to discover which part of the arrangement was doing more work than expected.

Shared computing taught us to negotiate scarcity

Early computers were expensive enough that access itself was a substantial problem. Time-sharing offered an alternative to treating the machine as something each user occupied exclusively.

The Computer History Museum records the demonstration of MIT’s Compatible Time-Sharing System in 1961. Several people could interact with a shared computer through terminals, with the system allocating processing time between them.

The important change was human as well as technical. More people could work interactively without each needing a machine of their own. Sharing made scarce capacity more useful.

It also made coordination somebody’s responsibility. Who could use the system? What could they access? What happened when demand exceeded capacity? These questions did not disappear when computers became cheaper. They returned in more attractive interfaces.

The lesson was that access can expand without ownership expanding alongside it. That remains a powerful arrangement, provided the people using the system remember who controls admission.

Personal computing taught us the value of autonomy

The personal computer moved capability closer to the person with the problem. Work that might previously have required specialist assistance could increasingly be attempted at a desk.

VisiCalc supplied a particularly persuasive reason. The Computer History Museum describes the 1979 spreadsheet as an application that helped drive Apple II sales. A computer became useful to people whose ambition was to explore figures rather than become computer specialists.

That mattered because a spreadsheet allowed the user to change an assumption and examine the consequences. The machine shortened the distance between a question and an experiment.

But autonomy also distributes responsibility. A person can build a model without acquiring the habits needed to check it. A neat total at the bottom of a column does not establish that the formula includes the final row.

The lesson was not that users should return their freedom to a central department. It was that empowering people means giving them ways to inspect, understand and recover from what they create.

The web taught us that connection could be the product

The web reduced a different kind of friction. Information could be linked across machines through shared conventions, rather than requiring every participant to negotiate a separate arrangement.

CERN put the original World Wide Web software into the public domain in April 1993. That decision helped make participation possible without obtaining a licence from the institution where the system began.

A link is now so ordinary that its significance is easy to overlook. It lets one piece of work point beyond itself. A publisher does not have to contain everything a reader might need.

The architectural lesson was powerful: common rules can make independently produced things useful together. Cooperation does not always require common ownership.

Yet connection also distributes exposure. A service available from elsewhere must decide what to trust, whom to admit and what to reveal. Making something reachable is an achievement. Making it safe to reach is additional work.

The web did not abolish boundaries. It made their design more consequential.

The cloud taught us that flexibility has a meter

Cloud computing made obtaining computing resources less dependent on buying and operating the physical equipment first. Its distinctive proposition was not simply that the machine belonged to somebody else.

NIST’s 2011 definition identifies characteristics including on-demand access, pooled resources, rapid elasticity and measured service. Capacity could be obtained and released as requirements changed.

For a small team, that can remove a formidable obstacle. An experiment need not begin with a procurement exercise and a room that requires cooling.

The bargain is that convenience arrives with continuing dependencies and charges. A resource that can be created quickly can also be forgotten quickly. The invoice is less forgetful.

Cloud services can reduce operational work, but somebody must still understand availability, access and recovery. Outsourcing equipment does not outsource the consequences when the application stops.

The lesson was to distinguish what a provider manages from what the customer remains responsible for. “Managed” is a useful description only when somebody finishes the sentence.

Mobile taught us that context changes the task

Putting software in a pocket did more than make desktop work portable. It placed computing beside the event: the journey, the photograph, the customer visit or the thing that had just gone wrong.

Distribution changed too. Apple reported more than ten million App Store downloads in its opening weekend in 2008. That is the company’s own figure, but it illustrates the appetite for a convenient route from discovering software to using it.

The design challenge was no longer merely fitting a large screen onto a small one. A person standing outside in poor reception has different needs from someone sitting comfortably with a keyboard.

A useful mobile application must decide what matters now. It may need to remember unfinished work, cope with interruption or make a single action possible with one hand. A miniature version of every desktop control is not necessarily generosity.

The lesson was that access everywhere does not justify demanding attention everywhere. A device being available is not the same as its owner being available.

Generative software is testing our understanding of delegation

The current shift allows people to request results in language rather than specify every operation through controls. That can make unfamiliar tasks more approachable and familiar ones quicker.

There is measured evidence of benefit. In Noy and Zhang’s 2023 study of professional writing tasks, access to ChatGPT reduced average completion time and improved assessed output quality. Those findings describe particular tasks, not a universal replacement for professional judgement.

The new bargain concerns uncertainty. A system can produce something convincing without making its limitations obvious. It can also interpret an instruction differently from the person who gave it.

This makes verification and permission central to design. Drafting a message and sending it are different actions. Proposing a change and establishing that it works are different achievements.

The lesson is still developing, but it already looks familiar: making a capability accessible does not remove the need to understand its consequences.

None of the eras has finished

These periods overlap. Mainframes remain, personal tools remain, and a cloud service may contain software that predates the company selling it. The chronology is a way of examining changing priorities, not a claim that computing obeyed a succession of clean historical boundaries.

What persists is the need to match the arrangement to the work. Shared capacity, local control, open connections and managed services each solve particular problems. None deserves automatic promotion into an answer for everything.

The best systems often combine lessons their marketing presents as alternatives. They give people a simple action while preserving a dependable record. They automate routine work while making exceptions visible. They remain useful when the ideal conditions disappear.

Every era makes something easier. The serious work is discovering what still has to be done, and making sure somebody is doing it.

The next launch presentation will probably announce the end of software as we know it. Somewhere, an engineer will be checking that yesterday’s customers can still open their files. Both may be looking towards the future, but only one has remembered what needs to arrive there.