I've been reading a whitepaper from ~1997 on Microsoft's Distributed COM (DCOM) last night, and as I was reading it, I couldn't stop thinking: this is microservices. And it was really more than that - at least on the surface, this was microservices + orchestration + autoscaling + serverless, as well as, via Internet Explorer, component-based UIs with graceful degradation. That paper seems like a window to an alternate reality in which everything that's currently hot in tech has been done 20 years ago, except programming language-agnostic, using saner (i.e. binary) protocols, offline-first, and with advanced security built in from the start. I don't know why this is not our "real" reality, but I finally understand why MS was in a dominant position back then, and why IE was a hot thing.
EDIT: for the curious, the mentioned whitepaper is: https://www.softwaretoolbox.com/dcom/DCOM%20Technical%20Over....
Honestly this happens all the time. Not only do we seem to reinvent the wheel but we almost invariably reinvent it worse. Take 'dark mode' for instance. Everybody lauds that they can switch to a different theme that they feel is easier on their eyes, apparently oblivious to the fact that we could do that in Windows 95 with significantly greater and more granular control at the OS level. This industry is overrun with complexity fetishists who keep piling on more and more abstractions and calling it progress when they manage to catch up with the less-abstracted past.
There will always be a lag between the two, and it won’t just be ‘reinventing the wheel’.
I had a look at CORBA and it was horrible in many ways. Interestingly it’s something that works and is proven at large scale but nobody would want to have it for small/middle scale non enterprisy applications, and it might not even be a good idea at large scale depending on what properties are valued. In no way I’d see kubernetes with services as a worse version of it, we didn’t choose it just by ignorance or hype.
Same with “dark mode“ on win 95. Most programs couldn’t even properly handle text sizes, it was a i18n nightmare that was just brushed under the carpet. Changing text and background colors was the same, with some apps somewhat working because they Mostly relied on default widgets, and a mess of unusable apps on the side that just had text colors baked. You had a better chance to have it work by plain inverting all colors through the accessibility settings.
To be fair it’s still partly a mess now, but we are in a way better situation that in Win95 , it is understood at an application level, it actually makes sense now.
There's a deep conflict between the interests of users and software vendors, a conflict for control over presentation. It's blindingly visible on the web, and half the reason it's in such shitty state it is, but it also applies to desktop software. The problem is that for a vendor, application's UI and UX are marketing space, and they want total control over "user's journey". For the user, UI/UX are things that stand between them and the work they want to get done, so they want it to be effort- and bullshit-free. For non-tech-savvy users this implies "consistent with all other software they use"; for power users, this means "able to be altered or removed" - but both of those viewpoints require vendor to not have the final say about presentation.
In context of dark mode, an OS-level control over UI styling is a user-friendly feature. Unfortunately, it got defeated by vendors who want the UI to be their branding space, and now they have to begrudgingly add dark mode themselves.
EDIT: see also https://news.ycombinator.com/item?id=24918296 upthread, it seems to be a quite accurate description of what will happen if we let the vendor side win.
Most people don’t want “dark mode” as a pure accessibility feature in the sense of “whatever color scheme is fine as long as it’s dark everywhere”. That’s the reverse color feature in most OS.
Instead I/they want dark themes but with pleasing colors, adjusted depending on the screens and the widgets, having sane defaults for content that is usually supposed to be white, with exceptions.
Yes, that’s a tall order, it’s context dependent, and we might actually want to decide app by app if the dev did a good job and/or if dark mode makes sense, and sometimes change the theme in the app because it’s otherwise not great.
We end up in a patchwork of apps following dark mode and others not, with different themes applied that might not be triggered by the system.
For instance I use youtube, reddit and editing apps in dark mode only, while the rest of the system is in light mode. As you say it could be handled by the system in a super granular way, but it would add that much more complexity, and I actually chose the exact themes to be used in most of these apps, so centralization wouldn’t help anyway.
Yes, in terms of raw flexibility exposed to the user, customizable color schemes look great on the surface. They work to some degree, but fail utterly for a wide range of cases in practice. Not having them is progress after a fashion because it means giving up on an flawed idea. I will admit, though, that it is not easy to see why it is flawed when you haven't tried to design custom controls that have to convey more state than can be expressed using the standard OS colir palette.
I worked for a company whose software was/is based on CORBA and let me tell you, that thing really smells like microservices-before-it-was-cool.
You had a naming service, and each component would connect to the naming service on startup and resolve the endpoint for the components it needed.
And each piece of software had a component called ORB (object-request-broker) that was used to represent remote stuff (remote objects/endpoints). You could invoke method calls on this object (kinda/sorta, i'm making it simpler here) and it would forward the call in background, hiding the networking/serializing/deserializing details.
That whole things kinda reminds me of protocolbuffers, etcd and microservices. By using a cluster manager (Veritas Cluster Manager) you had a service groups, something that looked like a pod, in a way.
-----------
It's been a while, but I've started thinking that there's nothing really new. The problems we're facing are pretty much always the same, it's just that the solutions improve on different areas. Kubernetes for example helps a lot on the scaling problem and the standardization (both ops team and dev team have a common lingo, the kubernetes object model -- pods, deployments, services, requests&limits etc).
EDIT:
Just skimmed the article... Yup, DCOM was a competing alternative to CORBA.
If someone older than me would like to chime in and add some details, that would be lovely.
After fighting COBRA for a while KDE said this is too complex/slow and wrote DCOM (I might remember this name wrong) which gave them the parts they wanted without the overhead. GNOME stuck with COBRA longer, but I get the sense that they half agreed and were just hoping they could find a solution without abandoning COBRA (GNOME also had more corporate backers even in those days so there was probably non-programmer architects demanding they make it work). Evenually both agreed that they needed something more lightweight to solve the desktop needs and DBus came along.
Also, iirc, KDE's thing was named DCOP
If they had wanted interoperability, they could have implemented something more standards based as IBM did with SOM. But requiring Windows for all parts of distributed systems is very limiting.
Around 2000 or so, I was installing the Visual Studio -- Pre .NET Version -- on a number of new developer workstations. I was not a Helpdesk or Desktop tech, but worked supporting servers -- they sent me over to do the installs because invariably "something wouldn't launch". Different IDEs were used depending on what language you were writing in with this monster of an app that was used to write programs in Visual Basic[0]. And the program was 5-10 times larger than the largest installed application and came with 2 CD-ROMs worth of documentation that needed to be installed locally[1]. I remember I'd start all of the installs at the same time because they took several hours to complete.
[0] If it isn't obvious, this was a one-off job that I don't recall very much about. I didn't start using a Microsoft IDE until the first release of Visual Studio .NET (retroactively renamed "Visual Studio .NET 2002", I think).
[1] For the younger among us, that's about 1.5GB in a world where two years earlier 16GB of HDD was very expensive.
> saner (i.e. binary) protocols
.. which only had one canonical implementation on each end.
If I remember rightly, the protocol for accessing Exchange from Outlook was MAPI over either DCOM or DCE/RPC. Despite some reverse engineering efforts, this is why there were no Open Source drop-in replacements for Exchange, and clients accessing Exchange always did so over IMAP, thereby losing features.
Similarly SAMBA is DCE/RPC. https://wiki.samba.org/index.php/DCERPC
COM sadly has a number of unfortunate characteristics though: it's quite complex to learn and it's not very secure actually (de-serialization of complex types in C anyone?)
But I think it's a wonderful technology.
I was using encapsulated components with internal state and defined interfaces more than two decades ago and it was old technology even then.
The web is a funny place, they grab something and claim it's revolutionary but often forget to mention where it came from.
It's not a bad thing but I have often joked if you want to see what is considered state of the art in Year X go see what the academics where doing in (X-20) years.
Its nothing like COM, but a vision of what moderns browsers engines could turn into (focusing on the properties you have mentioned).
We should not let "them" dictate dumb clients (and apps) to us that consume from the fog that "the cloud" is.
This is a corporate trend that will take a lot of freedom from us, and if we let them have their way, it will be pretty hard to get us all out of this nightmarish future we are heading to.
For some reason that I fail to understand, it seems that most computer protocols and most computer file formats are designed under the unstated assumption that those using them will not have access to a computer.
How much did it though? Strictly speaking, an OS is an abstraction on top of hardware that applications are written against. That's it. OSes of 2007 did a good job of abstracting the hardware away from applications. They also weren't as user-hostile as the modern ones, so one could argue that they were better. Operating systems had been feature-complete for quite a while. Those yearly updates serve no practical purpose.
The original author is arguing there will be a point where there’s simply nothing new to add to the browser because it will do everything the OS does. There are any number of ways to argue just not how it works.
An aside: as someone who comes from Android app development and now makes a hobby project that includes a web interface, making the browser do what I want it to feels like I'm building a UI in a Word document, complete with macros. The ability to have this free-flowing text that isn't contained in anything, this whole concept of "inline elements" still hurts my head. I'm too used to real UI frameworks where any text is only allowed to exist inside a TextView.
If you were on Windows it was tricky then as you had to download and configure your own tcp/ip stack. That was possible due to the ingenuity of Peter Tattam who sold software that let you do that. I met him back then and to some of us he was a true rockstar programmer.
Of course there's a wikipedia article on this, which counts 10k+ web sites at the end of that year: https://en.wikipedia.org/wiki/List_of_websites_founded_befor...
For most applications you would dial up a remote system anyway so many used the web by way of plain terminal software. The Lynx web browser had existed for just over two years by then and it wasn't the first web client.
For example, see "The Original HTTP as defined in 1991": https://www.w3.org/Protocols/HTTP/AsImplemented.html
It may not have been ubiquitous as it is today, but the web was definitely not out of reach for normal people back in '94.
What transformed the web was the launch of the Mosaic along with NCSA HTTPd - mostly in the backend of 1993 - it took off like wild fire - it's hard to remember dates, but I definitely remember the launch of Netscape Browser - which according to wikipedia was late 1994 - and at that point the web was already pretty popular.
Not just the web, but a large percentage of people had their own websites - it was ridiculously easy to do - just put an index.html in your ~/public_html folder.
Obviously this was all the in rarefied atmosphere of academia - and the computers were Unix work stations and most users were at University and largely PhD students at that.
I think it was Christmas break 1993 when a high school friend came to visit (he went to a different college) and started up Mosaic. I asked him what it was and then he laughed that I was still using Archie and FTP to find stuff.
I think it was xmosaic version 0.9 or something like that.
Your comment doesn’t seem accurate, it was starting to catch on pretty aggressively by 1994.
My first experience was sending an email with the url I wanted to access to a server that would send back the hypertext document a few minutes later.
Edit: Something like https://www.mcall.com/news/mc-xpm-1996-02-20-3077566-story.h...
In 2003, we got broadband internet at our house. Before then, when we only had dial-up, only a single computer in the house could use the internet. Broadband internet brought with it external modems you could connect to via wifi rather than sitting inside your computer [1], and this meant you could use other devices than the primary family computer to browse the internet, even assuming you had more computers in your household than just the one.
The iPhone came out in 2007, and is generally credited with ushering in the smartphone revolution. The iPad came out in 2010, making a somewhat larger form factor to enable the touchscreen interaction with the computer. From observation of my 3-year-old nephew, his ability to meaningfully use the computer via keyboard and mouse is quite limited. And I'm not sure he's all that capable with the touchscreen; he still hasn't understood that the reason he can't see me is that my phone doesn't have a camera and tries pushing stuff on the phone to make the camera turn on, inevitably resulting in him pushing the "end call" button.
I can totally buy a 10-year-old in 2007 who had never used the internet, especially if they came from a poorer household that didn't have the ability to keep up with technology and lived in a school district that didn't have the ability to give all their kids laptops.
[1] This does also show my age, as I never experienced the age of external modems connected via serial cables.
The age of 13 seems to be a common thread with a lot of developers -- I know of 5 others who will point to that age as "when they started writing software". It was age 13 when I started assembling and selling PCs (in the 90s) and began exploring software development and before my 14th birthday that I had re-written a BBS application in PASCAL.
Like you, I had been messing around with my (horrible) computer[0] since it arrived in our house and I was presented with an `A>` with no clue how to proceed, but it wasn't until I was 13 that my Dad presented me with a plan and a book to fix that problem[1]. I wanted a 386 so I could play Wing Commander (and see more than the 4 colors that my CGA display allowed -- loved the LSD trip that games like Kings Quest would put you through while trying to render decent graphics using practically nothing, but I was ready to be done with that).
I remember thinking my dad was insane -- he owned a business selling things to large automotive manufacturers ... nothing event adjacent to computers. And a computer was easily the most complicated consumer electronics device a person could own. Having had to fix our 8088 a few times, and being generally the most "handy person" I've ever known, his response was a dismissive "they're all just a bunch of parts that you buy and put together". And while I'm pretty sure he helped me build/troubleshoot the first couple of them (we had some bad components early on from a vendor in California), I generally built/tested/assembled all of the few hundred that we sold, myself. If you want a 13-year-old to behave more like a "Grown Up", well, when your Dad's friends are paying you thousands of dollars to build them a computer, you start to act like someone who's worthy of receiving that kind of trust.
The best part: we built the first several computers to pay for the one we wanted for ourselves[2]. My dad owned his company. I'm willing to wager that he could have afforded to just buy the thing for me and probably wouldn't have felt all that guilty about spoiling his kid since I was using it 99% of the time to do things other than play games. But this served as a forcing function -- I got the exact computer with the exact specifications that I wanted without having to think about the cost of those things provided I could sell enough computers to purchase it. I did. And I got to buy a convertible for my first car with money I had earned.
I'm seeing it now, in my own kids, two of which turn 13 in the next few months. They're working with Roblox's developer tools making new worlds and I'm staring over their shoulder thinking: this application is easily as complicated to use as any of the design tools I've been exposed to and these kids are just ripping through it like it's "not work" (if only they were getting paid!).
I've been looking for things to motivate them to step out of the "game world" and realize that the things they're doing could be done outside of Roblox -- they could make real applications, but much like I didn't believe my dad when he handed me that book, they haven't had that "ah ha" moment, yet.
[0] My friends all had Commodore 64s and such that played really cool (if slowly loading) games and cost a few hundred dollars. We had a $3,000 IBM 8088 clone with a 10MB hard drive and floppy drive that ... wasn't fun.
[1] I can't remember the title completely but it was something like "Build an 80486 PC and Save A Bundle"
[2] My 80486, if memory serves, cost just shy of $10,000. We went with what would be called "server hardware" these days: SCSI over (very new) IDE or (very old) MFM -- we went SCSI with a full height 360MB drive (40MB drives were huge), a very nice video card and a 18" CRT display (14" was 'normal' with anything above starting at twice the price of the best 14" display). And two modems... I ran a multi-node BBS on custom software originally based on Telegard.
But there will always be special purpose browsers. There is "TOR browser" today, and we will have "vintage web browsers" the same way we have CLI/TLI browsers still today (thinking of elinks and lynx), or the same way as there are still FTP clients and Gopher clients.
https://www.theverge.com/2020/10/20/21524665/stadium-stadia-...
You can get one issued for free just by demonstrating that you actually control the domain.
So yeah, even today there are use cases for custom CAs.
It also doesn't really have the problem of "unapproved" sites. You are already installing a certificate on the client. It's no extra work to add another trusted CA at the same time.
Local operating systems, which this essay says is the gold standard of feature sets, are not standing still. If you think of how long it will take for browsers to reach current parity, go back that amount of time and see how far the OS has come.
But let's consider, for a moment, that browsers catch up. Let's just look at native development in general, since this has had access to all local OS features since before the web. Has that never changed? It's changing all the time. We're finding higher abstractions to work with. We're making it easier. I highly doubt Grid and Flexbox as they exist today will still be how web layout works in 20 years.
Google isn't even the first to scare the world. This essay could've been written in 2002...about Internet Explorer. Stop laughing. It held even more dominance than Chrome does today, and was closed source. Somehow we survived...which is good, because VRML sucked.
However, even with all that aside, people have been rolling their own browsers for years. People fork chromium today. The dark web exists. Maybe in 20 years lots of people will be streaming everything from a private cloud supercomputer vis-a-vis Stadia. The internet is no more homogeneous than all the people of the world. Everyone is finding new ways to access it all the time. This is why open standards are more important than browsers. It means anyone can build their own at any time based on the documentation and it can all read the same documents.
So I wouldn't worry about this coming to pass in quite the way you think. Though running your browser in a VM isn't the worst idea.