I tend to focus on the origin of the computer within the military. Particularly in the early days of digital computing, the military was a key customer, and fundamental concepts of modern computing arose in universities and laboratories serving military contracts. Of course, the war would not last forever, and computing had applications in so many other fields—fields that, nonetheless, started out as beneficiaries of military largesse.

Consider education. The Second World War had a profound impact on higher education in the US. The GI bill made college newly affordable to veterans, who in the 1950s made up a large portion of the population. That was only the tip of the iceberg, though: military planners perceived the allied victory as a result of technical and industrial excellence. Many of the most decisive innovations of the war—radar and radionavigation, scientific management and operations research, nuclear weapons—had originated in academic research laboratories at the nation's most prestigious universities. Many of those universities, MIT, Stanford, University of California, created subsidiaries and spinoffs that act as major defense contractors to this day.

Educational institutions bent themselves, to some degree, to the needs of the military. The relationship was not at all one-sided. Besides direct funding for defense-oriented research, in the runup to the Cold War the military started to shower money on education itself. Research contracts from uniformed services and grant programs from the young DoD supported all kinds of educational programs. For the military, there were two general goals: first, it was assumed that R&D in civilian education would lead to findings that directly improved the military's own educational system. Weapons and tactics of war were increasingly technical, even computer controlled, and the military was acutely aware that training a large number of 18-year-old enlistees to operate complex equipment according to tactical doctrine under pressure was, well, to call it a challenge would be an understatement.

Second, the nation's ranks of academics made up something like a military auxiliary. The Civil Air Patrol built up a base of trained pilots, in case there was ever a need to quickly expand the Air Force. By the same logic, university programs in management, sciences, and education itself produced a corps of well-educated people who would form the staff of the next era of secret military laboratories. Well, that's not exactly how it turned out, with the Cold War's radical turn to privatization, but it was an idea, anyway.

That spirit of military-academic collaboration is how a group of researchers, mostly physicists, at the University of Illinois found themselves with military funding to develop a system called "Programmed Logic for Automatic Teaching Operations," or PLATO. With its origins in the late 1950s, and heyday in the 1970s, PLATO is usually considered the first effort in computerized teaching. It's a fascinating sibling to other large-scale computer systems of the time, like those in air traffic control. There are many similarities: PLATO struggled with connecting terminals and computers over a large area, before "the Internet" was even an idea. It had to display graphics, a very primitive computer capability at the time but one that was thought to be vital for classroom demonstrations. The system supported many simultaneous users, and had to process data in real-time to synchronize their various workspaces.

There were also important differences. Unlike SAGE and the 9020, unlike business accounting and tabulation systems, unlike almost every computer application yet devised, PLATO was designed for user-facilitated content.

Reflecting its origins among academic physicists, PLATO heavily emphasized collaboration. Many of the earlier, 1960s-era PLATO developments focused on simplifying the development of learning modules so that teachers could create interactive PLATO courses with less specialized computer training. By the 1970s, as PLATO terminals were increasingly installed in schools and other institutions in Illinois, the emphasis on collaboration turned towards communication. If learning modules were easy for teachers to develop, the students should also be able to use the system to create their own coursework and study materials. Researchers and other academic users had a similar desire for a computer system where they could keep notes, write reports, and stay in touch with their colleagues.

PLATO did not prove an enduring success—despite a decades-long effort toward commercialization, it was expensive and the actual benefits of computer-aided teaching remained unproven. Few PLATO systems ever escaped the University of Illinois and its network of satellite delivery locations. Follow-on projects fizzled out and, despite PLATO's incredible ascent from a 1960 concept to an elaborate 1970s multi-user interactive system, PLATO spent the 1980s in decline. No one thinks about PLATO very much any more, which is unfortunate, because it is one of those remarkable, isolated moments in history, a sort of conceptual singularity, in which a project with limited real success incubates so many concepts that it sets the course of history afterwards.

When you look at our modern computers, smartphones and social media and Farmville and so on, it's hard to find a single thing that isn't somehow derived from PLATO. Through PLATO's 1970s NSF funding and resulting interaction with other NSF efforts, it is my opinion that PLATO is probably a more important precursor to the modern internet than ARPANET and NSFNET. Not so much in a technical way; PLATO was closely tied to a mainframe-terminal architecture that would not have likely lead to our flexible packet-routing internet architecture. Rather, in a vibes way. PLATO was a large-area, networked computer system that emphasized posting things and looking at things other people had posted. It offered math lessons, but it also offered games.

Perhaps most importantly, it had notes.

PLATO's developers at the Computer-Based Education Research Lab of the University of Illinois had long had a simple way of communicating with each other, by editing a series of lessons titled "notes1" through "notes19." While functional, it was imperfect: Google Wave had not yet appeared to tell us that everyone being able to edit everything is good actually, so the complete lack of access controls, or formatting, or really organization of any kind was making the "notes" lessons a headache as the system gained users. In 1972, the PLATO IV terminal, new funding, and new backend computers had PLATO growing fast. There was an obvious need for a better version of the notes lessons.

Through the machinations of academia, the task of building a better "notes" file fell on two high-school students, on their summer break from the University of Illinois-affiliated laboratory high school. Using PLATO's native TUTOR programming language and facilities intended for exams and course discussions, Dave Woolley and Kim Mast wrote a lesson called "=notes=". The =notes= lesson was originally intended for system announcements, trouble reports, and communications between PLATO's operators. Soon, though, it was doing far more.

PLATO's notes were not the first implementation of a computer-based discussion board. Similar capabilities had been implemented by ARPANET users at least a couple of years earlier. It was also not the first email system, and indeed, was not email at all: notes only offered public posts. PLATO didn't gain a private messaging capability at all until a year later. The notes lesson wasn't even the only message board on PLATO, although it was the most sophisticated.

What stood out about notes is that it was popular. Everyone used it. By 1976, the notes lesson had evolved into a generalized application that allowed any PLATO user to create and manage their own notes file. That management included access controls and capabilities we might now call moderation. It was one of the most popular applications on all of PLATO, and that was against the competition of the several notable early video games created there.

Brian Dear, author of "The Friendly Orange Glow," a book on PLATO, argues that the notes lesson's peculiar history as a public messaging system that came before a private one had a critical impact on PLATO's users and culture. Communications on PLATO were "public-first." While a "private notes" feature was added later, users were already in the habit of doing things in the open. This sense of community, of close collaboration with some and passive awareness of others, must be a cultural precursor to the BBSs of the early internet and the social networks of today.

But that's not even what I'm here to talk about. During the late '70s, there was something else going on at the University of Illinois: future Microsoft CTO Ray Ozzie was working on his undergraduate in CS, a large part of which involved PLATO. After his graduation in 1979, he worked for Data General, manufacturer of a popular series of minicomputers, where he reported to Jonathan Sachs. After Data General, he did a stint at Software Arts, the development firm behind VisiCalc. He must have stayed in touch with Jonathan Sachs, though, who in 1982 had left Data General to found his own company: Lotus Development.

Lotus is widely remembered for Lotus 1-2-3, the hit spreadsheet application that displaced VisiCalc as possibly the most important software package in all of personal computing. Lotus's two founders were Sachs and Mitchell Kapor, both of whom had connections to Data General and Software Arts, in an era in which blockbuster software products often came from companies founded by a few entrepreneurial employees of the incumbent that was on its way out. And, indeed, they stuck to the familiar recruiting strategy: Ray Ozzie, of similar employment background, joined Lotus in the early '80s as a developer on their complete office suite, Lotus SmartSuite .

Lotus 1-2-3 was one of the most successful software products ever, but the frontier of office computing was quickly expanding to word processing and presentations. Far from our modern monoculture of Google Docs and Microsoft Office still kind of hanging on I guess, the productivity software market was extremely competitive in the 1980s and just about every Independent Software Vendor had some kind of productivity or office suite under development. The vast majority of these were commercial failures, and Lotus SmartSuite was no different . It is fascinating to consider that SmartSuite included an (apparently mediocre) desktop database/rapid application development tool called FORMS. Desktop databases were once considered table stakes for productivity suites, but are now almost completely forgotten, recast as expensive and standalone SaaS offerings like AirTable. But I digress...

By 1985, Lotus had acquired VisiCorp and consolidated its dominance in PC spreadsheets. Despite its overwhelming success in spreadsheets, Lotus struggled elsewhere: not just SmartSuite and Jazz but standalone word processor Manuscript and modeling-oriented spreadsheet Improv were often technically impressive but were also consistently poor sellers. I think that part of the problem is that the people at Lotus were a little too smart. This is best exemplified by their unsuccessful "personal information management" or PIM product (this is the same general category as Microsoft Outlook and Mozilla Thunderbird, although historically PIMs were less email-centric and more focused on calendars and contacts).

Lotus Agenda was marketed as a PIM, but unlike other contenders of the era, it came without a fixed schema into which the user inserted data. Instead, it behaved more like a very simple desktop database, with the user entering data into spreadsheet-like tables however they wanted and then defining views based on column and row filters. The result was highly generalized, able to fit just about any use case with sufficient time and effort. It also did very little to help: you started with a blank grid, left to your own devices. It reminds me of modern PIM-adjacent offerings like Emacs org mode or Obsidian that attract a fervent following of dedicated users who ascribe some sort of life-changing experience to them, while the other 99% of us launch the software and then wonder what we are supposed to do. Lotus Agenda, for its part, reportedly had a similar cult fame.

I imagine that Lotus's difficulty entering new markets must have encouraged them to get creative. They had quite a few products, many of them the subject of awards or technical papers or patents, no lack of engineering capability. What they seemed short on was vision and marketing. They had not quite figured out what customers wanted, or at least what customers wanted that was different from what their competitors already offered. I suppose they were willing to take a bet, as long as the risk could be adequately controlled.

In 1984, Ray Ozzie left Lotus to found a new company called Iris Associates. Like Software Arts developer-publisher relationship with VisiCorp, Iris Associates was an independent company but was contractually obligated to offer exclusive publishing rights on its products to Lotus Development. In exchange, the first few years of Iris's operation were funded by a substantial investment from Lotus. Ozzie, now in control of his own kingdom, quickly hired three other University of Illinois alums—people he knew from his time working on PLATO.

It's not clear to me if this was the original goal of Iris Associates or if it became the goal as a result of their experience with PLATO. However it happened, Iris Associates spent about the next five years building a version of PLATO's =notes= lesson that could run on a network of Windows PCs. Through their publishing arrangement with Lotus, this would come to be known as Lotus Notes.

Lotus Notes is one of the most famous, or infamous, examples of "groupware." Groupware is a hard concept to put your finger on, in good part because of its history. The whole thing, as a category, is easily traceable to Douglas Engelbart's work on Human Augmentation at SRI—work that, like PLATO, failed to gain market adoption but was nonetheless tremendously influential on the larger art. Human augmentation is the core idea in groupware, also called computer-supported cooperative work (CSCW). These were lofty academic ideas around the ways that computers could augment the social processes behind most productive work; they were ideas that grew and forked like branches from the middle of the 20th century to today. Many of those branches withered and died, others flourished before some sort of rotting disease set in (looking at you, Sharepoint). The result is that "groupware" meant different things at different times, and today is so non-specific that everything from enterprise business process automation platforms to slightly dressed-up webmail are lumped together.

In the days of Iris Associates, groupware meant something like this: software that assisted humans in communicating, collaborating, and tracking and executing processes. In practical terms, this meant core PIM applications like email and calendaring, but also included collaborative editing, workflow automation, document and policy management, and all kinds of other core business needs that involved more than one person. It's hard to apply a definition of groupware to Lotus Notes because Lotus Notes was one of the major products that originally defined the category, so its capabilities and limitations have become part of the background.

Lotus was under development from roughly 1984 (founding of Iris) to 1989 (first commercial release). The time period also put Lotus Notes in another category, although this one even more tenuous: network operating systems. Novell NetWare, for example, hit the scene in 1983. Network operating systems revolved mostly around file and printer sharing, but most gained some form of email. Lotus Notes had substantial overlap with network operating system features, but ran on Windows, making it an important step in the decline of fully integrated network products like NetWare in favor of application software on Windows which, more and more with each Windows release, used underlying operating system capabilities instead of implementing a complete application-specific network stack. Novell would go in a similar direction, with GroupWise, part of a wild industry restructuring during the 1990s.

It's hard to put a finger on what exactly Lotus Notes was from a modern perspective because the software itself was highly generalized. Wikipedia puts it like this: "Notes and Domino is a cross-platform, distributed document-oriented NoSQL database and messaging framework and rapid application development environment that includes pre-built applications like email, calendar, etc." Let's set aside for the moment the matter of Domino, which we have not introduced, and focus on the parts like "distributed document-oriented NoSQL database" and "messaging framework" which are strange ways to describe a groupware package but actually a very logical way to describe a rapid application development product—mentioned here as just one of the things that Lotus Notes is. I suppose that's a bit of synecdoche.

Like Lotus Agenda before it, Lotus Notes was something of a blank canvas that could be configured, customized, and designed to meet virtually any need. Unlike Lotus Agenda, they had learned a lesson about onboarding and Lotus Notes came out of the box with a set of familiar groupware features. What set Notes apart from other implementations of email, for example, is that Notes email was just another set of views and logic built on a common database. It was a custom application like the others, just one already provided as a sample.

Much of the strangeness of Lotus Notes reflects its origins in PLATO. Most of the microcomputer network products of the 1980s were built around peer-to-peer networking, the idea that multiple small computers could communicate with each other directly (NetWare, for example, used a peer-to-peer architecture despite the fact that certain machines were usually clearly logical servers). That was the hot new thing in the '80s, but PLATO was not of the '80s, it was of the '60s. PLATO wasn't even really a client-server architecture: it was a terminal-computer architecture, in which individual PLATO terminals interacted with one of multiple (mostly DEC) mainframe or midsize computers that ran the actual logic.

PLATO wasn't just multi-user, though, it was multi-computer. To form one integrated system out of multiple independent sets of computers and terminals, PLATO replicated all of the user data between the computers. Lotus Notes inherited the same approach: data was stored in a database, and communicated between users by replicating that database between machines.

Everything in Lotus Notes is a note, and a database is a collection of notes that are identified by unique IDs. When a note is updated, that note is replicated to other copies of the database. Over time, the obvious performance and reliability problems with this architecture became apparent and the replication process became a lot more sophisticated, but it always worked on this simple logical model of updating the local database and then replicating it to others.

And that was about it—the database full of notes was all there ever was to Lotus Notes. That and an incredible amount of functionality exposed to the user by the fact that notes could incorporate simple scripts, arbitrary programs, workflow rules, and entire GUI layouts. Lotus Notes did not differentiate between "user data" and "program data" at a low level, and indeed users could edit views, write scripts, and build entire applications on top of Lotus Notes that replicated to other users just like an email.

The kind of freedom that Lotus Notes gave its users was incredibly empowering, but also a bit of a nightmare for usability. I am reminded of the early object-oriented work, like Smalltalk, much of which came from a similar milieu of SRI and Xerox-inspired applied computing research. If everything is a note, then you can use the tools for manipulating notes to create anything. The Lotus Notes data model was extremely flexible, about as close to completely schema-less as practical, but it still offered indexing and full text search. There wasn't much that you couldn't shove into Lotus Notes if you tried, and for businesses that adopted it wholesale, it could expand in scope until it took over everything. Not just email and calendars but enterprise resource planning!

Early versions of Lotus Notes, before the IBM acquisition, allowed for programming using either an expression language very similar to Lotus 1-2-3 spreadsheet formulas (and called, sensibly, Formula) or an imperative language very similar to Visual Basic (called LotusScript). Using a tool called Designer, it was possible to visually edit GUI interfaces like forms and reports. These were backed by a Notes-specific query language, although later versions of Notes also gained an SQL compatibility layer and some options for interoperating directly with relational databases.

Because of the example of PLATO, Notes was architected around a client-server model. The client, generally called Lotus Notes, partially replicated the database to allow the user to view and edit notes. The server, which came to be called Domino, kept a complete copy of the database and executed enough of its logic to handle access controls. Like PLATO's replicated model, though, it was not expected that there be a single, central server. Many Domino servers could share the same database, and replicated changes among themselves. This architecture was very convenient for the era's business deployments, where each office location would have a local area network but network connections between sites were expensive and comparatively slow. Domino servers had the effect of consolidating user activity into a reduced volume of replication traffic, and when inter-office network links were lost the office still functioned normally, albeit as an island.

Despite its origins as a product explicitly for Windows, Notes maintained a degree of cross-platform capability. Domino was available for several platforms and the Lotus Notes client was available for pretty much anything. The simplicity of the Formula and LotusScript languages did a lot to simplify porting, although the system itself was originally written in C++. That all started to change when Lotus rolled in Iris and shortly after, in 1995, merged into IBM.

Lotus Notes is hard to write about because of the naming. The curious decision to call the server (which was, originally, called Lotus Notes Server) Domino already complicates the situation, and that itself appears to be a result of IBM's unique product vision. The IBM renaming churn went on for the whole span that Lotus operated under IBM, meaning that whether you call it "Notes" or "Lotus Notes" or "IBM Notes" or even refer to the entire thing as "Domino," you're probably correct for some point in the history. Modern IBM documents use elegant language like "the Notes and Domino product family." I have opted to just stick to Notes.

IBM was tremendously invested in the development of client-server microcomputer applications in the 1990s, unsurprisingly since they were the closest match to IBM's traditional strength in mainframe systems. The acquisition of Lotus was, no doubt, intended to advance that focus: Lotus Notes must have been one of the most prominent client-server products of the Windows '95 era. Its architecture, something like a "thin client" system that was derived from its mainframe precursor, felt akin to IBM's block terminals and generally fit well with IBM's approach to microcomputer applications (small client, big backend).

IBM was also investing in another project that fit their client-server vision: Java. Java was originally designed for embedded applications (interactive television!), but by its first official release in 1996 it had grown into more of a general purpose business application platform. The Microsoft .NET platform is a good later comparable, starting out where Java ended up. The "standard edition" and "enterprise edition" split of Java, and web service platform concept developing around them, fit client-server applications well. Java was widely seen as an easier, more productive language than C++. Best of all, Java's origins as a portable language to run on lightweight, embedded VMS made it a perfect fit for software that would need to run on a variety of different clients.

Lotus Notes 1 through 3 had been iterative improvements, from 1989 to 1993, adding features and fixing defects. With Lotus Notes 4, spanning 1996 to 1999, IBM Lotus Development started on a wholesale port to Java. Java was added as a native scripting language, alongside Formula and LotusScript, and many newer Lotus Notes features were "Java first." The Java-ization of Lotus Notes could be said to have completed in 2008, when the Lotus Notes client was completely replaced with a full-Java implementation based on Eclipse .

Alongside the new world of the object-oriented user interface, IBM also adapted Lotus Notes to the web. Version 4 introduced a very simple web interface where users could view static notes through a web browser, and IBM added an SMTP bridge for interoperation with other email systems.

At the dawn of the 2000s, Lotus Notes' technical leadership had eroded. The state of the art in GUI applications was far more advanced, and Microsoft had invested in their own groupware products (Exchange and Sharepoint). As part of the Windows Server offering, the Microsoft products were better integrated into the Windows desktop experience. IBM's investment in web technologies had lagged, so while Sharepoint was never exactly a hot rod, it was easier to interact with than Lotus Notes.

Still, development continued apace. IBM retired the Lotus branding around 2002, decisively folding IBM Notes and IBM Domino into Big Blue. Domino Web Access provided a web interface by 2002, although it was limited and not much different from what we would now consider mere webmail. IBM introduced SameTime, an instant messaging system that integrated with Lotus Notes. QuickPlace, similarly, was a web-based file/document management system that integrated with Lotus Notes as well. Both of these were even initially Lotus-branded, although IBM dropped that practice a few years later (and, for some reason, renamed QuickPlace to Quickr. It was a time).

When we talk about Java and the web, you might remember something, perhaps with a shudder: applets. In 2008, IBM introduced XPages. XPages were basically Java Server Faces components that ran on Domino server. They interacted directly with the Notes database and were, in some ways, just web-based versions of Notes forms. You even edited them using Domino Designer, the IDE for "serious" Notes development. Unfortunately, XPages hewed too close to JSF and remained a separate platform from Notes itself. You could not simply view existing Notes forms via XPages, or even readily port Notes interfaces to XPages format. If you wanted to support both the desktop and web experience, as most businesses would around 2010, you tended to end up writing things twice. Next thing you know, you're only really actively maintaining the web version, and then you might as well be on Sharepoint which was then well established.

To me, the most captivating part of Lotus Notes is its decline. In the mid '90s, Lotus Notes was the dominant groupware platform by a wide margin—Forbes put Lotus Notes market share at 64% in 1995. In 1997, they had fallen to 47%. A 2008 survey put Lotus Notes at 10%. Considering the long cycles and sheer staying power of enterprise software, that was a remarkable fall—all the more so considering that at that peak, IBM spent over $3 billion to get their hands on it.

Admittedly, IBM buying a popular software product at great expense and running it into the ground is an old story. But there's another major player here too: Microsoft was at their best. The vast majority of Lotus Notes' users went directly to Microsoft Exchange, which besides its higher level of integration with Windows (both at a technical and sales level) was also agreed to be more performant and easier to maintain. I would wager that Microsoft was at their peak engineering competence in the early '00s, and they had a considerable late-mover advantage over software that carried all the baggage of predating open-standards TCP/IP networking. NetWare went into a precipitous slide for the same reason.

Standards themselves are another important part of the story. Early email systems were all proprietary, and weren't necessarily networked systems at all—the first email implementations just stored mail on the single machine that all of the users accessed via terminal. Lotus Notes having a completely proprietary implementation of email didn't stand out in that world. When Microsoft first launched Exchange, it had the same limitations. That changed fast, albeit more by accident than intention. ITU X.400 had been expected to provide the standards for email on the public internet, replacing the hodgepodge of proprietary and network-specific open standards. Instead, X.400 failed to do much of anything at all—but not before it became the basis of Microsoft Exchange.

Exchange ended up in sort of a standards purgatory, an implementation of an open standard that died before Exchange could even launch. Exchange's X.400 capabilities became a proprietary standard of unusual origin, and most of industry and academia opted to follow the NSF example and adopt the older and simpler SMTP. Microsoft apparently understood that interoperability would be critical for the future of email, so Exchange was marketed from the very start as a multi-protocol system that could speak SMTP as fluently as anything else. That wasn't ever 100% true, but it was the idea that mattered. Lotus Notes had SMTP support but it was lagging behind, Exchange was the future focused on interoperation.

The web story was almost exactly the same. That's not to say that Exchange had a good version of a web interface, Microsoft has famously struggled with messes like Outlook Web Access. But they were still more agile than IBM, and their complete vertical control of the desktop experience meant that their weird proprietary web technology (ActiveX) fared better than IBM's weird proprietary web technology (a confusing tangle of Notes browser plugins and Java applets). Besides, Lotus's web features were apparently separately licensed at great cost. Microsoft wasn't cheap but, in this case, they were the budget option.

Last of all is the elephant in the room. It is hard, today, to explain exactly what Lotus Notes was. That's not a recent problem. In 1998, Forbes wrote:

Even before IBM arrived, Notes' identity had been blurred; it's no clearer now. First the software was marketed as a system to make it easy for a widely dispersed group of employees to work together editing a document or managing a project. Then Notes was redefined as a tool for building customized collaborative applications. Now Lotus seems to be playing up the E-mail function in Notes and positioning it as a replacement for cc:Mail. The latter was once a leader in its field but is now suffering a slow death.

cc:Mail! That's a whole different article. So let's stick to the point: the fact that Lotus Notes sort of defined a product category became a liability as other vendors muscled in with more targeted, more narrowly focused, and more obviously useful competition. Lotus Notes started to sound like Zombocom: You can do anything! Microsoft was just selling email and calendar. Notes' large scope was a problem for the user experience as well; besides the fact that the Notes client looked and felt dated by the '00s, the generality and depth of its capabilities meant that it was also just plain hard to use.

In 2018, IBM sold what remained of Lotus Development to an Indian software company called HCL. HCL is a classic IT consulting firm, with a portfolio that spans "Industry 4.0" to "SAP consulting." They acquired Lotus as part of a bundle of IBM castoffs: some of you might remember BigFix. Lotus Notes is now HCL Notes, and as far as I can tell HCL intends to just enjoy the revenue as long as legacy customers will pay them to keep Notes running.

That's another part of the allure of Lotus Notes: it might be the most legacy of legacy software. I have never worked at an organization that was using Lotus Notes, but everywhere I've worked that wasn't a startup had a powerful institutional memory of back when, in the Lotus Notes Times. Some people remembered it fondly, most people remembered it hatefully, but they all remembered it.

Will GMail ever inspire such emotion?