A lot of things have come and gone in the last few decades in computing. This post will cover a short list of topics that I saw in my career that were either notable or that people used to argue about a lot. Or both. Some of this might be a fun trip down memory lane, and some may be PTSD-inducing, but it is important to periodically look back in computing to learn from past experiences, as things that seem inevitable outcomes today weren’t always so clear at the time. This post will look at distributed computing, operating systems, and networking.
Distributed Computing
DCE
DCE (Distributed Computing Environment) was an RPC (Remote Procedure Call) framework that started in the late 1980s and developed in the early 1990s. It got a fair amount of industry vendor attention, particularly with a transaction processing system called Encina, but much less so on implementations. DCE may have been advanced in concept, but never really went mainstream.
CORBA
CORBA (Common Object Request Broker Architecture) started in the early 1990s, it experienced a brief but notable surge of interest in the mid/late 1990s with Java, as Java’s “run anywhere” goals overlapped with CORBA’s. A lot of people talked about CORBA and quite a few even tried it, but also found out that implementing and deploying CORBA-based solutions was quite complicated, as was multi-vendor consortium coordination to push the whole thing forward. It didn’t help that Microsoft wasn’t a fan. A 2006 ACM Queue article did a great job describing how things played out.
EJBs
In the late 1990s, it looked like Java was going to take over the world, and Enterprise Java Beans (EJBs) seemed to be well-placed to become a widescale pattern for distributed computing combined with Java application servers. Initial versions of EJB also utilized CORBA under the hood. Unfortunately, much like with CORBA, developers found out that the EJB development and deployment paradigm was more complicated than expected, and the resulting technical benefits weren’t always worth the complexity. EJBs are still a part of the Java ecosystem for backward compatibility (no small feat), but I would hazard a guess it’s been a while since many new EJBs have been written.
DCOM
Microsoft, especially during the 1990’s, was very much opposed to “run anywhere” if it meant anything other than Windows. Thus, DCOM (Distributed Component Object Model, originally “Network OLE”) was born. Microsoft saw DCOM as the way all developers would build distributed applications, at least on Windows. DCOM still exists, but I would estimate it is only utilized today by hard-core Windows developers and not for general solution development.
SOAP
After experiencing DCE, CORBA, EJB, and DCOM all in a single decade, one might think that the computing industry would have been burned out with distributed computing and RPC frameworks. But like a true technical romantic, The Next Thing was always around the corner. SOAP (Simple Object Access Protocol) is an XML-based framework that was started in the late 1990s and eventually became a part of the W3C (World Wide Web Consortium) standards in 2003. SOAP had a lot of momentum and it seemed like the way distributed computing was going to be solved, until it wasn’t. SOAP was eventually replaced by REST and JSON as the default Web services implementation pattern a decade later. I’m sure there are places with a lot of SOAP messages though, as legacy code doesn’t re-write itself.
Operating Systems
Unix
Just about everybody knows the high-level Unix story arc: created back at Bell Labs back in the early 1970s and notable for many reasons, such as being the first portable operating system, a modular design, as well as being written in the newly created language C, itself tailor-made for writing portable systems code instead of using assembler.
What is less discussed is how Unix became so popular. It’s hard for the younger generation to imagine now, but there used to be a single phone system in the United States and it was owned and operated by the Bell System/AT&T. People didn’t even own their own phones; I remember my parents renting theirs from the phone company, and long-distance calls were a very big deal. Critical to the Unix backstory is a 1956 antitrust case forbidding AT&T from entering from the computer business. The United States would allow AT&T a monopoly in telecommunications, but the potential of a chunk of the computing sector on top was asking too much. The result was that AT&T could build systems for itself, but could not release computer products. If AT&T could have sold Unix to the masses, it would have. But it couldn’t.
Consequently, Unix’s source code—originating from the premier research lab in the country—was available to anyone who asked and wanted to license it. This wasn’t “open-source” as we understand it today, but it was available source, which was still significant because you couldn’t call IBM and get the source code for the System/360 mainframe, for example. Unix was advanced source code that could be studied and improved. It found a strong foothold in academia and then an expanded following among those who wanted to keep using it in other settings, and really hit its stride in the 1980s. And in the 1990s, everybody loved Unix; it was the hot workstation/server operating system. On top of being modular and portable, however, Unix also became notable for its eventual fragmentation into Sun’s Solaris, IBM’s AIX, HP’s HP-UX, SGI’s IRIX, SCO Unix, BSD Unix, and others. Everybody loved Unix —as long as it was their Unix.
Linux, which dates from the early 1990s, was in many ways a response to this fragmentation. Could the Unix ecosystem be made simpler and more collaborative with open source? The answer was sort of yes, and sort of no. It seems history has repeated itself to a large degree with Ubuntu, Debian, Fedora, CentOS, RHEL, etc.
Unix isn’t “history,” of course, as it is still running many servers around the world. But it’s also clear that the spotlight in operating systems has been on Linux for quite some time.
OS/2
A lot has already been said about OS/2’s failure in the PC marketplace despite IBM’s efforts during the 1985-1994 timeframe. I think the main thing to note is that failure wasn’t inevitable. Microsoft was probably a tough business partner in the early development (easy to forget that Microsoft and IBM were actually co-developing OS/2 in the beginning), and there were probably parts of IBM that still weren’t crazy about OS/2 and PCs because they saw it as a threat to IBM mainframe and mid-range systems. OS/2 might be an exceptional case, but it isn’t unique in the annals of business partnerships and product development. A 2019 Ars Technica article does a terrific job covering what happened.
Taligent
You might think that the OS/2 experience would make IBM leery of another operating system co-development project, but you would be wrong. Taligent started as an Apple/IBM partnership in 1992, based on earlier work at Apple code-named Pink. While an unlikely match, it is easy to forget that during this timeframe Apple also had its own set of operating system concerns due to the rigid constraints of the original Mac design initially released in 1984. HP was briefly involved as a business partner from roughly 1994 to 1996. Taligent wandered around for years and it never released its targeted operating system TalOS, and was not infrequently described as a “death march project.” It did, however, eventually deliver a complex application development framework called CommonPoint. Taligent was dissolved in 1998.
BeOS
Speaking of Apple and operating systems, Be Inc. was formed in 1990 by a former Apple executive all too familiar with the 1980’s Mac strengths and weaknesses. The BeOS operating system was released in 1995. In 1996 Apple was considering either licensing or acquiring BeOS but eventually bought NeXT instead—a deal that came with NeXTSTEP operating system as well as Steve Jobs. The last BeOS release was in 2000 and Be Inc. closed in 2002.
Networking
Token Ring
I remember Token Ring adapters from early in my career, mostly because the adapters were huge and dangerous if swung overhead. Token Ring networks were deterministic and supposed to be more reliably performant, but they were also more expensive. It’s a long story, but eventually Ethernet took over.
“The LAN”
“It’s on the LAN” was an exciting phrase back in the early 1990’s. The LAN (Local Area Network) meant that information was sharable. The LAN meant collaboration! But the LAN was frequently a disorganized place, like everybody’s data basement. Which letter drive was the document on? S? T? U? X? Y? Z? And which directory? There were always so many directories. And so many ways to accidentally delete things. The LAN was better than walking around with files on a floppy disk, but it was also like driving on a semi-finished highway without a seatbelt.
Some things today are very different as we aren’t talking about Banyan Vines or Novell NetWare anymore. But some problems are still with us as Microsoft Teams sites and Sharepoint directories don’t magically organize themselves. But at least with modern cloud-based tools, file-searching has improved drastically, collaborative editing has removed the need to pass files around, and version control can track changes and restore the occasional mistakes that are a fact of life.
Final Thoughts
What can we learn from these stories? Managing business partnerships in product development is tricky, as well as the resulting ownership of intellectual property. This is even more complicated with industry consortia, and there is also a huge difference between an industry specification and a functioning deployed system. Once deployed, systems don’t manage themselves. Lastly, today’s greenfield development will be tomorrow’s legacy code. Those lessons never go out of style.
References
- BLOG@CACM
- Distributed Computing
- CORBAEJBDCOM
- Operating Systems
- Networks
Doug Meil is a software architect in healthcare data management and analytics, and an ACM Senior Member. He also founded the Cleveland Big Data Meetup in 2010. More of his BLOG@CACM posts can be found at https://www.linkedin.com/pulse/publications-doug-meil