New York Times 1989 doubts multitasking usefulness; concurrency irony for modern devs

Level 1: One Thing at a Time?

Imagine someone telling you, “Hey, you should only do one thing at a time, because why would you ever need to do two things at once?” It sounds a bit silly, right? It’s like saying you must sit and watch the kettle boil from start to finish, and you shouldn’t chop vegetables for dinner until the water is done boiling. In real life, we know it’s perfectly normal (and efficient!) to do a couple of things together or in quick back-and-forth chunks — maybe you’re baking and while you wait for the oven timer, you start washing the dishes. We do little “multitasks” like that every day without thinking about it.

Back in 1989, a big newspaper essentially said something like that about computers: “Oh, this new ability for a PC to do two things at once is neat, but an average person won’t really find it useful.” Today, that statement is funny because we all rely on our computers and devices to multitask constantly. It’s hard to even notice it because it’s so normal: your phone might be downloading an update while you’re texting a friend, or your laptop might be playing music while you write an email. If our computers could only do one thing at a time, we’d be incredibly frustrated (imagine your music pausing every time you opened a new app!). So, the joke in this meme is basically pointing out how a long time ago people didn’t realize how important doing many things at once would become. It’s as if someone in the past confidently claimed, “Nobody will ever need to juggle tasks, one is enough!” — and here we are today, juggling tasks all the time and very glad we can.

Level 2: OS Juggling Act

Let’s break down what that quote is about in simpler terms. An operating system (OS) is the main software that manages your computer’s hardware and runs other programs. In the late 1980s, the most common OS for IBM PCs was MS-DOS, which really could only do one thing at a time. If you were using a DOS computer in 1989 and you wanted to open a spreadsheet while a document was printing, you were out of luck — you had to wait for the print job to finish, because the system wasn’t truly multitasking. The quote in the meme comes from a newspaper article talking about a new OS (likely IBM’s OS/2 back then) that introduced “real concurrency.” That means real multitasking: one program can continue running in the background while you switch to another. In everyday terms, the computer could juggle two or more tasks at once, instead of doing just one single thing, start to finish.

At the time, this was a pretty amazing concept to average PC users. Imagine you start copying a large file to another disk (which might take a couple of minutes on a 1989 machine). On a DOS system, during those minutes your computer would be entirely tied up with the copy process — you couldn’t do anything else until it was done. But on a multitasking system, you could begin the file copy and then switch over to another program to, say, write a letter or play a game while the copying continued in the background. The article’s author was essentially asking: “Does an ordinary person really need that fancy ability? How often do you even run something that takes long enough to bother doing two things at once?” From their viewpoint, most programs an average user ran (like a calculator or a simple word processor) finished tasks quickly, so why complicate things?

What the article missed is that even in the late 80s there were everyday situations where doing two things at once was useful. For instance, downloading a file over a modem could take several minutes, or printing a document on a slow dot-matrix printer might leave you waiting. Without multitasking, your computer would just sit there dedicated to that one job. With multitasking, you could let the download or print happen “in the background” and still use the PC for something else “in the foreground.” That was a game-changer for productivity and convenience.

Today, of course, all of this is taken for granted. Modern operating systems (whether Windows, macOS, Linux, or the OS on your smartphone) are built from the ground up to handle many processes at once. You might have music playing, a web browser open with multiple tabs, incoming emails, and a video chat all happening at the same time. Concurrency is the technical term for this ability to handle multiple things simultaneously. The way it works under the hood is by context switching really fast between tasks. The OS is like a fast juggler: it gives a few milliseconds of attention to one program, then switches to the next, and the next, and so on. Each program runs for such a tiny slice of time and the switches happen so frequently (many times per second) that to us users it feels like everything is running in parallel. In reality, if there’s only one CPU core, tasks are just taking turns on that one brain of the computer — but those turns are so rapid we don’t notice the pauses. On a multi-core processor (which is common now), a computer truly can run several tasks at the exact same time, one on each core, which makes multitasking even more powerful.

So, the quote from 1989 is funny now because it underestimated how useful this OS juggling act would become. The HistoricalContext here is that people hadn’t yet seen how much multitasking could change their workflow. Terms like ConcurrencyModels in the tags refer to different ways an OS can handle multiple tasks (for example, cooperative vs. preemptive multitasking, which differ in how the OS switches tasks). But the big picture is: back then, someone thought “real concurrency” was just a fancy trick with not much practical benefit for normal folks. They turned out to be very wrong. Today an average person might not say “I love concurrency” in so many words, but they absolutely love what it does for them — it’s the reason you can listen to music, download files, and edit a document at the same time without your computer breaking a sweat.

Level 3: Small Use, Big Irony

"'More amazing but of small use' — that 1989 proclamation now reads like a comically poor tech prediction." Modern engineers and power users can hardly imagine a world without some form of multitasking. The humor here comes from hindsight: the New York Times confidently downplayed a feature that is now utterly fundamental to computing. It’s essentially the “Who would ever need that?” of the late ’80s, in the same spirit as other famously shortsighted quotes in TechHistory (think of the apocryphal saying, “640K ought to be enough for anyone,” about memory). Back then, the writer looked at preemptive multitasking on a new IBM PC operating system (likely IBM and Microsoft’s OS/2, which was pioneering true multitasking on PCs) and presumed it was overkill for the “average person.” Today that notion is laughable: even non-technical users constantly have multiple apps and processes running.

Anyone who has lived through the evolution of OperatingSystems will nod at this. In the MS-DOS days, if you wanted to download a file or print a document, your whole machine was effectively occupied by that single task. Many of us remember staring at a progress bar, unable to do anything else until it finished. The quote’s author saw those scenarios as minor inconveniences at best – after all, how often would an average user run a task so heavy it takes minutes? Fast forward to today, and the answer is: all the time. We routinely run programs that do take more than a few seconds (think of virus scans, photo edits, video renders, or even loading a bloated modern webpage). And thanks to multitasking, we don’t sit idle watching a progress bar; we switch to another window and keep working (or procrastinating on YouTube).

The meme strikes a chord with developers because we appreciate the irony on multiple levels. First, there’s the historical irony: a journalist dismissed a capability that turned out to be a cornerstone of modern computing. It’s like reading an old article that once scoffed at the usefulness of the Internet or touchscreens — in retrospect, it’s adorably wrong. Second, there’s the shared experience among developers of wrestling with concurrency. We’ve dealt with threads, locks, and race conditions, and we know how much engineering effort goes into making true concurrency appear simple to the user. The quote’s blithe confidence (“small use to the average person”) makes us chuckle because we know the reality: under the hood, today’s systems are juggling dozens of processes and hundreds of threads so that the “average person” can, say, stream music while chatting in a video call and running a code compile in the background. The average person might not know terms like ConcurrencyModels or context switching, but they sure would notice if suddenly their computer could only do one thing at a time.

There’s also a subtle nod to how tech adoption works. In 1989, many people truly didn’t see a need for multitasking because they’d never experienced it. It’s the classic Henry Ford scenario of “if I’d asked customers, they’d have wanted a faster horse.” The Times article reflects a world where the personal computer was still thought of in single-task terms. Yet, as soon as multitasking became available and user interfaces grew more advanced, people’s behavior changed. We started expecting to run a music player while typing a document, or to have email open while browsing the web. That early skepticism feels quaint now. Indeed, OS/2 (and later Windows 95/NT) proved the naysayers wrong by showing how much smoother and productive a PC could be with true multitasking. The meme’s punchline, so to speak, is that the “small use” feature from 1989 turned out to have huge use for literally everyone. It’s a bit of techie schadenfreude to see a venerable publication get it so wrong. We laugh, but empathetically — predicting the future of tech is hard, and this meme is a reminder of just how far we’ve come.

Level 4: Preemption vs Perception

By 1989, the concept of real concurrency on an IBM PC meant implementing true preemptive multitasking — the operating system actively interrupts one running program to switch to another so both appear to progress in parallel. At the OS kernel level, this involves a hardware timer triggering a context switch: the CPU state (registers, program counter, etc.) of Program A is saved, Program B’s state is loaded, and execution jumps to Program B, all in a few milliseconds. The New York Times quote describes this as “more amazing” because for a typical MS-DOS user (accustomed to running one program at a time), it did feel magical to see two programs apparently running at once. However, OS designers and computer scientists already knew from earlier multi-user systems that concurrency was more than a gimmick — it was essential for efficient use of the CPU and a snappier user experience. Classic time-sharing theory from the 1960s showed that overlapping I/O-bound tasks with CPU-bound tasks keeps a system busy and users happy: while one program waits (for disk, network, etc.), another can use the processor. In 1989, hardware like the Intel 80386 finally provided the necessary support (memory protection, privilege levels, fast interrupts) to bring these multitasking tricks to personal computers. The perception in that newspaper snippet — that this was of “small use” to regular folks — missed the bigger picture. True, there’s overhead to context switching and memory management, and if each program only ever ran for a second, rapid task-switching might seem unnecessary. But the preemption of tasks was forward-looking: it not only prevented one misbehaving program from freezing the whole system, it also laid the groundwork for the rich, interrupt-driven multitasking every modern OS relies on. It’s the classic case of early skepticism colliding with what OS engineers understood all along: given the chance, computers (and users) will find plenty of work to do in parallel. Interestingly, even at that time, specialized systems had proven the value of multitasking — for instance, the Commodore Amiga (introduced in 1985) featured preemptive multitasking and delighted its users. Time-sharing principles from big iron machines were trickling down to the PC, and OperatingSystems research consistently showed that doing many things at once was key to responsiveness. The Times article’s stance was a snapshot of a transitional era, when the tech history of mainframe scheduling theory met the everyday reality of desktop computing. In short, the technical foundation for concurrency was solid, even if a 1989 journalist wasn’t convinced the average person would care.