Comment by madrox | Hacker News Reader

Comment by madrox | Hacker News Reader

When this essay started with "As someone who has used the Web since 2007" I immediately felt old, so thanks for that. As someone who has been using the Web since 1994 (and I feel like I was late to the game), I can assure the author their perspective has a lot of recency bias and this isn't something to worry about, in the general sense. Or worry about it, because it already happened a while ago. Take your pick.

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.

> This essay could've been written in 2002...about Internet Explorer.

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....

link to the paper?

Provided in an edit.

This still exists! COM serves as the foundation of modern windows apps you currently see on Windows 10 (WinRT). And still actively developed in its form as WinRT.

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'm currently having an opportunity to learn it, as I need to interface with a piece of legacy software that works over DCOM. I thought this would be a nightmare, as all my previous brief encounters with COM/DCOM left a bad taste (obscure errors full of GUIDs, registry hacking), but now that I'm actually trying to learn what the thing is, I'm becoming more and more in awe of it.

The thing holding DCOM back was that the protocol was closed source and unspecified. It’s very difficult to make Microsoft’s version of DCE RPC work with other implementations let alone their proprietary object extensions.

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.

A lot of stuff were "microservices" before the name was coined. SOA (as in service-oriented-architecture) was definitely a thing.

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.

Interestingly enough, the "N" in "GNOME" was due to the fact that it was initially based on CORBA, and used a C-language ORB called orbit (IIRC).

If someone older than me would like to chime in and add some details, that would be lovely.

KDE and GNOME agreed in the early days that both desktops would be based on COBRA and use standard object names so the two would be compatible.

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.

CORBA, not COBRA :)

Also, iirc, KDE's thing was named DCOP

The issue with KDE was that Qt was nonfree so there was also a few efforts to replace Qt with something else.

That is why gnome existed (now it is large enough to have a place), but a completely different issue from the corba one.

GNU Harmony and GNU NOME are two different projects from around the same time.

This is true for a great number of things. Our industry has a terrible collective memory - we're at such a rush to push aside the old in favour of new shiny stuff only to have to rediscover why it was useful (or not) later.

Visual Studio of 20 years ago was in many ways superior to Xcode of today, but you need Xcode to make iOS apps, and iPhones are cool. Moral of the story is better technology does not always win. It’s a fallacy that technology is a continuous positive progression.

So I say this having used XCode about 10 years ago, but is XCode really that bad?

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.

> 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.

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.

The problem with the fine grained user control over individual theme colors is that the OS theme is never complete enough for applications with visually complex UIs. At some point, applications have a need for extra colors to denote things in different ways. So they would need to provide their own configuration UI that allows the user to update these colors to be usable with any custom theme they're running. Unfortunately, most software developers never bothered to implement something like this and assumed the user would be running the default theme. So the users ended up with lots of broken UIs after trying to adjust the system wide theme.

I think we should separate ideas/proof of concepts that were in the field and presented as having potential, and implementations that are largely adopted and reliable.

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.

You could have "dark mode" in Windows 3.0. Provided programs used the standard widgets and the correct "named" colours, everything would pick up the colour changes from the operating system.

How on earth can anyone think that each application having to individually implement support for a bespoke "dark mode" is a better situation than having more granular controls in the OS and applications just follow the UI guidelines is beyond me. It's bullshit like that that makes me want to leave IT forever.

It's probably the unfortunate consequence of a typical software vendor's perspective.

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.

How on earth is the same set of UI icons supposed to keep their readability against vastly different background colors? If you want to do a proper job of that, your application needs to become aware of dark mode anyway and ship with a separate set of icons.

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.

It’s because reality is complicated.

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.

It often happens when the technology satisfies a need the market haven't really felt yet. Microservices are hot now because many companies and individual developers have already felt the pain on their own experience. Without such experience, advanced technology just seems "unnecessary complicated" compared to the simple LAMP-based monolith that "just gets the job done".

It may have been language-agnostic, but it was never going to be OS-agnostic. Like everything Microsoft it only worked with Microsoft implementations on both ends.

> 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

You will probably have a good time reading about the history of the Mach OS.

As far as I know SOA is a concept and DCOM and CORBA are implementations of this concept. Microservices are a more lightweight variant of SOA, but basically the same idea.

I felt the same with components.

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.

> using saner (i.e. binary) protocols

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.

If you are interested in those properties, you might like something i'm working on that i'm about to launch.

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.

I'm interested. Please, tell us more, and/or drop me an email (address in profile).

Good. Will drop you an email.

As some who has used the Web since 2000, I could not second more! Chrome dominance feels a bit better then Internet Explorer dominance, because the Microsoft browser was shitty about features and documentation (anybody remembers quirks mode and the IE box model?). In the grand, the overall topics did not change (in many cases it's always been about DRMs, OS support, being the first setting/implementing the standards/proposals). Unfortunately the web browser landscape got thinner. The decline of Opera and the modern Internet Explorer (what was his name again?) is a real loss for web diversity.

> go back that amount of time and see how far the OS has come.

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.

This same argument could be made about browsers depending on the value one places on specific advances.

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.

I personally don't think browsers need to be able to do stuff like exposing USB, Bluetooth and MIDI to websites. They aren't a substitute for a real OS as an app platform, and they should stop trying to become one. They're for reading (hyper)text, writing text (including filling forms), and watching videos.

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.

You literally couldn't have used the web much earlier than 1994 unless you were running a NeXT machine. I know because I've been on the net since 1988 and 1994 was when I first started browsing the web.

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.

You're right. The explosion of the multi-plaform web happened in 1993 https://en.wikipedia.org/wiki/Libwww

I was using the web in college in 1993. After my very first experience with a browser, i thought gopher was superior. Of course, a 1200 baud connection makes graphics a bit less impressive and more of a pita.

Lucky you, that had access to a graphical browser!

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...

That's a bit of a stretch. The web is hard to date, 1990 is often mentioned, but it had already spread quite a bit by 1994.

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.

I don't think I've seen 1990? You could make a case for 1991 or 1992, but I don't see how anyone could have been using the web in 1990 when it hadn't been even initially implemented yet?

For example, see "The Original HTTP as defined in 1991": https://www.w3.org/Protocols/HTTP/AsImplemented.html

Case in point – in '94 I was in fourth grade at a school that made a big deal of their computer department, and how they were hooked up to the web. When geocities launched ('95?) we were making homepages as school assignments. So many "under construction" images – it was glorious!

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.

Lynx was not a "web browser" in the current sense until 1993.

The first browser for windows was NCSA Mosaic. I remember installing that. When Internet Explorer came out it was so advanced! I remember it supported background images!

It seems the first one was https://en.wikipedia.org/wiki/Cello_(web_browser)

You could have also been in a college in 1994, as I was, where there was easy access to the new-ish at the time World Wide Web via every computer in every lab.

Your comment doesn’t seem accurate, it was starting to catch on pretty aggressively by 1994.

But 1994 is not much earlier than 1994, right? How is the comment you reply to inaccurate? The first non-NeXT browsers appeared in 1992 (unless you count the Line Mode Browser from 1991).

I started college in the fall of 1993. I went to a science and math boarding school for high school where we had Internet access. We used Archie to find FTP sites to find stuff.

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.

You could use the web before that, but with text based browsers which frankly weren't very inspiring nor popular. Most people preferred gopher etc - there was a brilliant mac gopher client.

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.

August 1991. https://en.wikipedia.org/wiki/Line_Mode_Browser

You could. X.25. Gopher.

That's not "the web".

That 2007 passage really brought me to a grinding hault. Toddlers are using the web these days from the moment they can swipe a screen. I have a hard time believing anybody on GitHub over the age of 20 only began using the internet in 2007.

The technology to let toddlers use the web didn't really exist until rather recently.

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.

I didn't regularly use the Internet until I was 13ish. I wanted to be fair in the timeframe so that's why I said that. I probably encountered the Internet many many times before then, but it was not for regular usage.

A little off topic, but thanks for sharing:

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.

Wow, really touching story :). It sounds like your kids are on a really great path with a great father.

In 20 years it will be impossible to manually browse to an unapproved "unsafe" URL in a general purpose browser.

Well, its hardly possible to manually browse an unapproved unsafe URL even today. Ever tried to browse a site with a self-signed certificate? In most browsers you have to do a lot of extra clicks to get in.

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.

iPhone doesn't allow true 3rd party browsers only reskinned Safari. Apple even removed a browser for extending safari too much [0]. So while there will be vintage web browsers, normal people may not have access to them.

https://www.theverge.com/2020/10/20/21524665/stadium-stadia-...

All the certificate verifies is that the server you are connected to actually belongs to someone who controls the domain that it's hosted at.

You can get one issued for free just by demonstrating that you actually control the domain.

There is so much on TLS beyond Let's Encrypt. For instance, TLS allows user certificates to authenticate the user, not the server. This works a bit like SSH passwordless login (thanks to key authentication). This technique only works if the site operator also controls a CA which the browser accepts. Companies can easily install self-signed certs to do so, but on the wild web that's quite difficult.

So yeah, even today there are use cases for custom CAs.

I'm aware that client certificates exist. I'm not aware of anyone actually using them.

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.

This is the real nightmare scenario...

Reply on news.ycombinator.com