[txutxu]

Booting a modern laptop, something I do every day, is the anti-low-tech paradigm.

Just my motherboard BIOS is 50348032 bits. And it doesn't provide many options, I think the other way around, it hides many options on purpose.

Then there is an i7 processor... a whole beast itself against simplicity. With its Intel Management Engine, it's microcode updates, etc.

Secure boot? UEFI? VT extensions? TPM? NFC? graphics initialization?

OK, so far, we've code and material to fill the whole life of an engineer, and we didn't reach still the OS bootloader.

Ah, the bootloader, who remembers lilo... here we go with grub. Go read it's source code, and return back to explain me everything that is in there... see you in 3 months only for this.

Here it goes, the kernel. A thing that normal users don't see or touch. More than 30 Million of lines of code more. I won't talk about complexity here, but this project can really say it's "batteries included". The same you get an old obscure filesystem/protocol nobody uses, than proc/mem/i-o/netowrk schedulers for supercomputers. Blobs, firmware, more graphics stuff, observability, wifi, storage, a whole word in itself and everything comes up in microseconds.

There is such initram thingy, which is another "mini" (not mini in lines of code) operative system. Busybox? xD look at that.

Now, here it comes... the low-tech king: systemd! our love-hated init system (only init? well you already know).

Now, here we can start the operative system (which may not bee too simple), we could be talking for years, of each of the micro-components that help to launch the base OS services until you get to the login page.

Depending on the distro... we're skipping a hell of complexity (it's not the same the ps aux of an ubuntu desktop, than the ps aux of a minimal system). Let's skip it, let's skip hundreds of software components and phone home stuff.

The auth part, gives for a few years more of reading code, talk about, skipping plugins and optional stuff.

Then you can get a window manager or a desktop environment (so a week or some months of code more), running over Xorg (do you think it's simple?) or Wayland (you can devote your life until you own this part).

And now... let's launch a "web browser". I will stop here, we won't finish if we go deep into the browser complexity.

Modern hardware, software and engineering, are a big ball of snow. The more it advances, the bigger and out of control it gets.

[roughly]

> The more it advances, the bigger and out of control it gets.

This is largely due to path dependency - there’s a required amount of “bigness” and complexity to do the things we want to do, but it’s substantially lower than the amount we have, because we’re not starting from zero, we’re building on what we already have. You can see this everywhere - telecom lines follow old train lines, keyboard layouts mirror old typewriter layouts, desktop file system layouts mirror old mainframe layouts.

It mirrors evolution in that way - the path taken is the cheapest path from the current location, not the ideal path, which is why a giraffe has the same number of bones in its neck as you do.

I’ve actually been interested recently in what it would look like to have a truly modern software & hardware stack built from the ground up for modern computing - I feel like there were attempts at this in the 90s (BeOS comes to mind), but even something like ChromeOS was basically Linux under the hood. It feels like the industry’s decided what we have is Good Enough, and that’s a bit of a shame, because you’re right, it’s really quite a ball of spaghetti.

[BobbyTables2]

A minimal Alpine Linux install is what — 10MB?

A minimal Debian/AlmaLinux install is closer to 1G.

What did we gain with 100X the space, larger attack surface, and configuration complexity?

Even hardware is this way…

Look at the weight and power requirements of a SFF PC.

Then look at a blade server… Still requires heavy steel case, heavier than SFF PC because it’s larger, only job is to fit into heavy steel enclosure. Enclosure requires beefy steel rack to handle weight.

Every layer makes logical sense but the end result does not!!

Older NAS servers held multiple 3.5” drives (heavy), requiring big power supply. Now a plastic clip holds NVMe drives onto a motherboard — no steel!

[npteljes]

The system is the result of the structure and power distribution of the entities that built it. Another compounding factor is that I don't think any of the creators had "simplicity" on the forefront, when building their respective part of the system. So, yes, the end result is not simple.

As for reading the code or anything like that, I don't think I would have managed even a C64, and that's, I think, way simpler than the modern computer you described. So I've been lost for a long time.

Life is just complex.

[overtomanu]

Yes, life is complex literally!!

Even our DNA has lot of "unused"/"dormant" code

[inciampati]

Not really, in that all parts of the DNA can and do interact with proteins and lncRNA in the cell. Where in code there can be truly unused portions which are only copied, in the cell all bits are functional. The reason we say they are unused/junk/dormant is that we have extremely limited ability to observe the system in its totality.

[dekhn]

Nope, there's definitely junk that is non-functional.

[082349872349872]

> Modern hardware, software and engineering, are a big ball of snow. The more it advances, the bigger and out of control it gets

a sentiment already expressed in 1963! https://news.ycombinator.com/item?id=35851599

[lambdaba]

> The more it advances, the bigger and out of control it gets.

Yet my present computer can do far more than the one I had, say 30 years ago, when things were "simpler".

[blueflow]

I keep an old Thinkpad around running Windows XP. Its some 512MHz CPU, so not really that fast. But: It boots faster, the UI feels less sluggish, you can tell apart buttons from inert text, and launching Age of Empires I and restarting my savegame takes like 5 seconds.

I keep this Laptop as living proof that computers did indeed get shittier.

[hkt]

I'm on a thinkpad x230t from over a decade ago, running Linux. It is a bit less vintage than yours, but I can confirm that for the princely sum of £200 on ebay, I can run a window manager and pretty much any software I want.

It replaced a £1500 starbook, which stopped powering on about a month after the warranty expired.

Not quite the same point as you, but I'll agree on something: old hardware that lasts is miraculous.

[nicolas_t]

I remember when windows xp came out. It felt so slow on my celeron 300 mhz (overclocked though) with a geforce 256, sluggish to a point that I happily switched to gentoo. Of course your Thinkpad most likely came late in the windows xp lifecycle so it feels snappier but the user experience when windows xp came out was anything but fast.

[olyjohn]

To be fair. Celerons were really terrible. I ran them for a long time (even was running dual celerons on a board at one point) and overclocked the crap out them. Then I switched to an actual Pentium 3 chip and it blew them away. Never went back.

[tonyarkles]

> even was running dual celerons

Another member of the ABIT BP6 club! My friends could not believe that I could play Counterstrike and burn a CD at the same time :D

[p_l]

Depends a lot on what you run.

Anything involving web? Uh.

A lot of things definitely got way faster though, they just are things that neither switched to most inefficient (computing wise) ways of doing it (Electron GUI) nor pay the "high resolution" tax.

My first own computer could hold the entire final displayed framebuffer in less than 1MB. The display I use right now requires a bit over 32.5 MB to do so, and switch towards more and more hires raster bitmap as method of drawing interfaces means it's schlepping probably over half a gigabyte every frame.

But things that don't need that? Even for python development (not running jobs, interactive development) my recent switch from Kaby Lake i5 to Zen4 resulted in noticeable speedup. Despite the previous machine already having NVMe SSDs etc.

[ben_w]

The web being slow is an example of UI in general becoming slow.

My experience over the years has been that UI frameworks are very fun to write but we'd all be better off if our managers said "no" to them — vanilla HTML is very fast, as is UIKit.

Likewise for development, while Interface Builder gets flack for the file format making it hard to collaborate or even to code review, actually using it to implement a UI from the design team is fast and easy compared both to UIKit in code and to SwiftUI (and SwiftUI is better than some of the other programmatic UI frameworks I've seen, though it also loses points for a WYSIWYG editor that gives up if you look at the keyboard wrong).

[p_l]

The web is slow because it's used in ways that it's not exactly designed for.

This means that even when you try your best, you can end up with very complex code paths for doing things that would be handled through simpler ways in "proper" GUI framework.

It's not really a dig at browser engines - they are very optimized. But they are very optimized because otherwise it would be even more unbearably slow.

[ben_w]

I'm not complaining about the browsers themselves either.

IIRC, almost every UI widget in iOS and Mac OS (even way back to 68k) and VisualBasic and Java is a rectangular interaction region, even if the appearance is circular.

A <div> with a background image and an on-click, on-mouse-move etc. handlers, can replicate the look and behaviour with much lower complexity than even the React tutorials I've done (I assume that React is even more complex in production?)

Last tech conference I went to, there was a talk on how to boost website performance by loading your JS in a particular order — at that point, I think you're better off with a website being an img and <img> and <map> and everything more than that being done on the server. Not that this is a good idea, just less bad than having so much JS you need to re-order it to keep load times down.

jQuery seems nice, from what little of it I've seen in practice.

[adrian_b]

While that is true, most of the current complexity has nothing to do with enabling the present computers to do far more.

Most of the complexity is caused either by the need to provide backward compatibility or by the fact that the many parties who design the components of a computer had very different ideas about which is the right way to design them (so many compatibility layers are required) or by the fact that the manufacturers insist on implementing various additional features that are not really needed, because they may be useful for them even if they are harmful for the final owner of the computer.

Many of the most horrible features of the modern computers have been caused by the fact that Microsoft could not be bothered to implement in their operating systems certain features whose right place was inside the OS and Intel has kept piling workarounds over workarounds in their CPUs, one more ugly than the other, like the System Management Mode and the Management Engine.

[BizarroLand]

Well, maybe, at least for Windows. If they rewrote their whole stack from the ground up for Win 12, eliminated everything that wasn't performant, and gave everyone the tools needed to adapt, 2 things would happen:

1: Windows would be insanely fast and incredibly unlikely to ever bog down or bluescreen for any reason, and 95% of my gripes with it as an IT professional would vanish into digital smoke.

2: Microsoft would be eaten alive by all of the people and companies suddenly finding the money and time to switch to Linux/OSX or just plain refusing to upgrade because an old printer driver or some bit of obscure hardware that only 13 people in the world use won't work on the new windows kernel without an extensive rewrite and the company that made it doesn't exist anymore.

[AndrewKemendo]

Conway’s law does not define a maximum size of a system.

It simply defines that the systems as measured reflect the structure that created them.

If you look at the software ecosystem as a whole, it is increasingly indivisible without the underlying structure, because interface types have been totally monopolized - you need a create a client-server REST/LAMP service with stateless agents consuming services

That is to say if you wanted to build a technical service, but that does not comply with existing trends in engineering then you just don’t exist

Technology is social it’s not simply mechanical

Socially, we don’t have holism as a goal. Cybernetics is socialism according to academia and increasing specialization means that nobody can fully understand the whole thing.

Because nobody can understand the whole thing there are opportunities for fragility, and basically stuff to break catastrophically with nobody knowing how to fix it.

I anticipate the next couple decades look like a lot of broken stuff that people rely on, that increasingly nobody knows how to fix

[galdosdi]

Maybe if you run the Arachne web browser for MS-DOS on an older non-UEFI intel machine, you might be approaching something where one person could still understand the whole sequence

[logtempo]

computers are complex indeed. That said, I don't think lowtech philsophy is about browsing HN with a Macintosh II. It does have this "get things done simple" branch, but also the ecology side of it, the reflexion about the relationship with technology, its social component, eventually the sovereignty we have over technology and its sustainability.

[p_l]

Honestly, I think a lot of the parts that people complain about aren't actually as complex as they seem - but they are the surface visible parts. And lack of knowledge and nostalgia glasses sometimes make people unaware of how complex things used to be.

A lot of underappreciated thing with boot firmware these days is that what is presented to you as end user is absolutely not connected to what options are actually possible. Also tons of complex and quirky code just to get the CPU and memory to the point of running other code. IIRC there's bits of code spanning early CPU reset and intel IME that are necessary to prevent the CPU from destroying itself, at least on some models. Similarly on AMD PSP.

Some of them will be disabled because the hw physically doesn't support them, or can result in weird behaviour that isn't going to be something you like, or effectively brick things.

Another part is that it allows real proper modularity of an open platform, at least on the vendor side. Add a new device that requires special driver? No longer you have to spend a long time just to integrate a blob, there's a standard API/ABI whether the driver is closed or open source. ACPI provides tons of ways to just specify the details of where something is and how to connect it. I love a lot about openpower, but PetitBoot is effectively less open if only because there's no possibility to use add-in card requiring drivers that wasn't already compiled into flash. With UEFI it works.

UEFI is honestly in many ways less complex than previous systems (no more hooking into tape drive boot sequence), especially since there's much less that needs to be in SMM block except for things required by hw (an example: some CPUs required SMM code for changing certain power levels, because the OS level API doesn't expose the low-level details like enforcing a synchronization point on all CPUs or low level internal registers).

If you use UEFI, you also don't need to implement whole complex (and IBM PC incompatible) craziness that is GRUB (or NTLDR with its ARC firmware emulation, or non-UEFI WINLDR which emulates chunk of UEFI...) - n.b. the last linux bootloader that properly handled IBM PC compatibility was LILO if installed in appropriate way (read: not how distros did it).

TPM and Secure Boot are reasonably easy parts of the whole thing. NFC and smartcards are also things that are reasonable for single engineer to grasp.

There's less visible, though some people remember about it, complexity that is enforced on us by corporate interests - big part of why AMD PSP is closed source is the same reason AMD was unable to open source some of the HDMI code recently - both AMD PSP and Intel IME are part of implementing "Secure Media Path", aka DRM bullshit for MPAA (HDCP and its DisplayPort equivalent). It's also why various DRM systems don't fully support fully open systems (for example normal linux distros, not ones that are built by vendor of a device with special blobs)

Now, systemd I'll agree it takes a good idea but does with horrible implementation, and that's from someone who gave in and tries to use it fully (mainly because I have no time to implement an alternative).

Wayland also makes in many ways life more complex than X11, OTOH XFree86 legacy of being lowest common denominator implementation even after reverting to X.Org means that people felt stuck.