In January 1990, Bell Labs called a press conference to unveil a machine the newspapers promptly christened the world's first digital optical computer. On the bench: laser beams bouncing through arrays of microscopic optical switches, a processor with — its builders hoped — no wires at all. Within five years the programme was wound down, the field's funding had evaporated, and "optical computing" had become a cautionary tale told to graduate students. And yet here you are, thirty years later, in an MSc course on computing with light, at a moment when photonic chips ship by the million. Fields do not usually rise from the dead. This lesson is the autopsy and the resurrection report: what the optical computing of the 1960s–90s actually was, the specific, nameable reasons it collapsed, and why the version that returned is different enough to survive. You already hold every tool the analysis needs — the carrier gifts, the photon-vs-electron verdict from this module's earlier lessons, and a working knowledge of optics itself.

The arc, at a glance

Act I — the analog spring (1960s–70s)

Optical computing was born analog, and it was born useful. Within a few years of the first laser (1960), engineers realised something remarkable that Module 6 will derive: a simple lens, fed coherent light, physically produces the two-dimensional Fourier transform of whatever image sits in its front focal plane — a million-point transform, computed in the time light takes to travel a few centimetres, for free. At the University of Michigan, Emmett Leith's group used exactly this to process synthetic-aperture radar data: film strips of raw radar returns, flown home from reconnaissance aircraft, were turned into sharp terrain images by nothing but lenses — at a time when no digital computer on Earth could handle the arithmetic. In 1964 Anthony Vander Lugt added the matched filter: place a carefully made mask (a hologram) in the Fourier plane and the optical system becomes a correlator, lighting up wherever a target pattern appears in the input scene. Pattern recognition at the speed of light, decades before "convolution" became a machine-learning word.

The analog spring's strengths and sins both matter for what follows: monumental parallelism and speed on one specific linear operation; but fixed function, analog precision, and — fatally — the input had to arrive on film. Getting data in and out of the optical domain was slower than the computation by orders of magnitude. Hold that thought; it never goes away.

Act II — the digital dream and the collapse (1980s–90s)

By the 1980s the ambition had grown teeth: never mind special-purpose lenses — build a general-purpose digital computer out of light. The hoped-for hero was optical bistability: devices whose transmission snaps between two states, an optical analogue of the transistor. Bell Labs' SEED (self-electro-optic-effect device, David Miller, 1986) and its symmetric successor became the flagship, and Alan Huang's team wired thousands of them into the 1990 demonstrator — laser beams clocking through free-space arrays of optical logic gates.

Why did it die? Not for one reason but for a convergent set, and it pays to name them precisely, because they are the checklist against which every photonic proposal is still judged. Robert Keyes had in fact published the checklist in 1985 — what makes a good computer device: gain (output strong enough to drive several inputs), cascadability (output the same signal type as input), logic-level restoration (noise squashed at every stage), low energy, and manufacturability in the millions. The transistor scores five for five. Optical gates failed on nearly every line: light does not amplify light (no charge, no interaction — the lesson-3 verdict in action), so every "optical gate" hid an electronic conversion inside; energy per switching event was worse than CMOS, not better; and the free-space alignment of thousands of beams was a manufacturing nightmare. Meanwhile the competition would not stand still: CMOS energy per operation was halving every couple of years, so an optical gate that matched CMOS at the press conference lost to it decisively by mid-decade. Racing an exponential is a losing sport. Module 7 performs the full post-mortem; feel the shape of the exponential yourself first:

The refugees of the collapse did not leave photonics — they went where light's true gifts were wanted. The erbium-doped fibre amplifier (1987) and WDM turned the 1990s into the golden age of optical telecommunications: photons for transport, exactly as their CV suggested. The irony sat quietly for twenty years: the technology built to move bits between continents was maturing into a manufacturing platform that would eventually move bits between chips.

Act III — the return (2010s–now)

Three things changed, and none of them was "someone finally invented the optical transistor." First, the platform: silicon photonics — waveguides, modulators and detectors fabricated in slightly modified CMOS fabs — turned optics from hand-aligned benches into lithographed chips, solving the manufacturability line of Keyes' checklist for the components that don't need gain. Second, the demand: Dennard scaling ended and data movement became computing's dominant cost — the interconnect problem this module opened with, which is precisely the problem light solves. Third, the workload: deep learning made one operation — the dense matrix product, a linear operation — worth a fortune, and linear operations are the one thing interference computes natively. The emblem of the return is a 2017 MIT experiment (Shen et al.) running a small neural network through a programmable mesh of Mach–Zehnder interferometers: Vander Lugt's insight reborn on a fingernail of silicon, pointed at machine learning. The economic logic is the case for domain-specific architectures in its purest form: when general-purpose scaling falters, specialise. So the field returned not as "the optical computer" but as three sober product categories — accelerators for linear algebra (Modules 4–6), interconnects (Module 8), and quantum photonics (Module 9), which needs light's coherence rather than its switching.

Where this goes next

Sixty years compress into one design rule: light computes best what light does naturally — propagate, superpose, interfere — and fails when asked to decide. The final lesson of this module turns that rule into a map: a taxonomy of everything now called "photonic computing", from analog meshes to quantum samplers, and the route this course takes through it.