Hacker News Reader

Comment by fbdab103 | Hacker News Reader

Isn't that exactly how things improve? When you can reduce the cognitive load on bookkeeping, you can accomplish more productive work.

I can produce a featureful webapp in Python-Django solo because I do not have to worry about optimally filling registers and CPU cache. As you cut deeper to the hardware limitations, you have to be significantly more cognizant of writing to the hardware constraints than solving the business problem.

Taken to the extreme, we have Electron applications consuming multi-GB of RAM, but it does expand the universe of possibilities.

View on HN

> Isn't that exactly how things improve?

There's a joke "20 years of software progress has completely undone the 20 years of hardware progress."

Essentially the joke is about how people don't optimize software like they used to. There is some tongue in cheek though because there are more platforms and variations that we have to account for these days but there is also truth that there is some laziness. I mean I have a laundry app on my phone that takes 5s to load each time because it redraws the home screen while it is trying to connect to the network and find the machines but won't use the bluetooth or nfc chips that both my phone and the machines have.

I do think there is the case to move fast and break things, but at some point you got to slow down and fix things. There should be cycles. Don't forget that debt has interest and that interest compounds. If you have enough debt you'll be "moving fast" but being fast in molasses isn't fast. It's kinda why a lot of software have just declared bankruptcy and started over (e.g. "rewriting in rust"). We should definitely encourage people to hire a mixture of those that move fast and those that move slow. There's harmony there but I think we've forgotten that.

> Isn't that exactly how things improve? When you can reduce the cognitive load on bookkeeping, you can accomplish more productive work.

What are you talking about? Sure you can appear to be more productive if you are reckless and wasteful of resources, and adding more resources means there is more that you can afford to waste.

But for the past decade or so we have been seeing what happens if you teach every software developer that it's okay to waste resources: resources get wasted.

Back when you couldn't afford to waste resources, you'd see extremely skilled optimizations and extremely clever hacks to get advanced software to run on extremely slow and primitive CPUs. But ever since computing power increased by a couple orders of magnitude, what happens? The exact same software implemented by today's developers would more than compensate for the increased computing power by being a couple orders of magnitude less efficient.

Sure it expands the universe of possibilities. I do want more resources, I really do. But "reducing the cognitive load on bookkeeping" is making software get slower faster than hardware gets more powerful. Which is absolute insanity to me.

Think of all the software which does not exist if we are still writing in assembly because we are constrained by the hardware. Python, RPGMaker, Roblox, PICO-8, etc are no longer possible because they are too wasteful. Having bounty enables art to be made which is impossible if creators are bit twiddling.

Do I bemoan that my 2000s era super computer squanders resources to load 20 kb of text? Sure, but it is also amazing the things that are possible because tools are not restricted to the priesthood of assembly programmers.

> Think of all the software which does not exist if we are still writing in assembly because we are constrained by the hardware.

There is an entire spectrum between "640k ought to be enough for anybody" and "this app needs its own fully independent copy of an entire browser engine just to display a couple screens of text".

About Electron: Operating systems provide their own system-level webviews. Use those. Tauri uses those; Tauri apps are absolutely tiny and use very little RAM, because the system-level webview doesn't have to duplicate the overhead of an entire browser engine for every single app that uses it. It typically only has to duplicate the overhead of a single page.

But that is for apps that even need a webview. For apps that don't, you don't have to drop all the way down to assembly to pick something like WinForms. Even WinUI 3 isn't always terrible, at least compared to webviews.

Hell, I wonder if even Python + wxPython would be more efficient than using a webview. Honestly, none of the software you mentioned is "too wasteful", or at least those aren't what I was referring to with my original comment.

Have you heard about Microsoft Teams, and how it can take up to 10 seconds just to display the splash screen, even on a decently fast computer? I'd like to see you try to tell me that it would have literally killed them to optimize it a bit more. Just think back to, say, the IRC clients from back in the Windows 7 days where you wouldn't even have to blink before they finished opening up.

Another example is just how few simple optimizations I see in code now. Something like

   `while i < someFunction():`

Instead of

   ```
   criteria = someFunction()
   while i < criteria:
   ```

I've seen simple lines like this compound in complexity as someFunction() gets more complex or as the loop increases. There's a billion variations on the idea but I think it is because people aren't thinking about how someFunction() is getting called every iteration. I do think every programmer should have some basic optimization skills just because these types of things would be nonobvious otherwise. Because frankly, this kind of optimization is going to have no real difference in a toy program or even in many isolated test cases but it can easily add meaningful latency to a program. Definitely more egregious examples but just trying to think of something that is extremely low hanging fruit.

The real issue comes when the user is doing things more than just your program...

wouldn't any compiler optimize this anyway?

No, and a lot of python code is written these days.

I have this theory that if you remove too much friction then things get worse. Because when there's friction it makes people cognizant of limitations. But when there's not enough friction it becomes easy to sweep aside or ignore. You can be too reliant on your metrics. Idk if this actually makes sense but maybe there's a nugget somewhere in the idea.

Reply on news.ycombinator.com