The Decade We Forgot

There was a moment somewhere between 1988 and 1998 when computing stopped feeling alive.

We did not notice it at first. The screens grew sharper, the CPUs faster, the GUIs prettier. But something subtle and essential faded: the idea that a computer was knowable.

1. What Happened

The transition from personal computing to consumer computing was quiet but total.

  • 1980s: Individuals explored, extended, and hacked their machines. Lisp Machines, Smalltalk, Amigas, and early UNIX workstations were open worlds of experimentation.
  • 1990s: Corporations standardized and scaled. Windows became dominant, UNIX turned industrial, and Java promised portability at the cost of transparency.

By the millennium, we no longer asked how computers worked. We asked what version we had.

2. The Cultural Inversion

The first generation of hackers built systems as conversations between human and machine. The next generation built systems as products for markets.

Curiosity became risk. Exploration became inefficiency. Reflection was rebranded as overhead.

We stopped teaching liveness, introspection, and coherence, and taught frameworks, layers, and interfaces instead.

3. The Rise of Layers

As teams grew, every new abstraction was justified as simplification. But in truth, each layer solved a coordination problem, not a conceptual one.

  • Middleware abstracted over kernels.
  • Frameworks abstracted over languages.
  • Containers abstracted over frameworks.
  • Clouds abstracted over everything.

Each solved short-term complexity by hiding it. Eventually, the only thing we could understand was our own layer.

4. The Economics of Forgetting

Lisp Machines and Smalltalk systems were not defeated technically. They were defeated economically.

They were too elegant to commodify. Too coherent to scale cheaply. Too powerful to control.

C and UNIX, on the other hand, were portable and reproducible, a manufacturer’s dream. The market rewarded mass production, not conceptual integrity.

Innovation gave way to industrialization. Depth was traded for reach.

5. Overengineering as a Social Habit

When development became corporate, engineering became defensive.

  • Layers reduced friction between teams.
  • APIs replaced trust.
  • Standards replaced understanding.

We engineered our tools not for creativity but for safety in numbers. And so complexity metastasized.

Today’s overengineering is not stupidity. It is fear made solid.

6. Complexity vs. Complication

Old systems had complexity that was earned, the elegance of compression. Modern systems have complexity that is accidental, the entropy of scale.

Conceptual complexity:

  • Comes from rich ideas and few rules
  • Produces depth that can be understood
  • Feels coherent and intentional

Accidental complexity:

  • Comes from layers, wrappers, and frameworks
  • Produces sprawl that obscures understanding
  • Feels fragmented and hard to hold in mind

We replaced deep simplicity with shallow convenience. It felt like progress because we kept shipping.

7. The Real Regression

Technologically, we advanced. Culturally, we regressed.

We built systems that no single human can fully grasp. We turned computing into paperwork. The hacker spirit became the sysadmin’s burden.

In the 80s, an entire OS fit in your head. In the 2020s, a single web app requires a cloud region.

We did not move backward in capability. We moved backward in relationship.

8. The Blind Spot of Scale

Scale became the universal justification, the corporate catechism.

But scale kills intimacy. It rewards predictable mediocrity over imaginative risk.

The more we scaled, the less we understood. The less we understood, the more we abstracted. The more we abstracted, the less we controlled.

And soon, we were building systems that only systems could manage.

9. The Memory That Remains

A few lights never went out:

  • Emacs Lisp, the living editor that still breathes.
  • Smalltalk and Pharo, the live image that still persists.
  • Oberon and Plan 9, monolithic coherence still runnable.
  • Common Lisp, self modifying power in a modern compiler.
  • Retrocomputing projects, rebuilding clarity one boot sector at a time.

They are not nostalgia pieces. They are reminders, living fossils of a lost lineage.

10. Why Remember

Because forgetting was not inevitable. It was a choice hidden inside progress.

If we remember what it felt like when our tools were transparent, we can build modern systems that breathe again:

  • Reclaiming liveness.
  • Restoring introspection.
  • Designing for comprehension, not compliance.

Closing Thought

The decade we forgot was not about losing technology. It was about losing trust in ourselves to hold complexity without fear.

Now, with AI generating code and machines that imitate thought, we need the old wisdom more than ever.

Computers were once living ideas. It is time to remember what that meant.