The world could run on older hardware if software optimization was a priority

If dynamic array bounds checking cost 5% (narrator: it is far less than that), and we turned it on everywhere, we could have computers that are just a mere 950X faster.

If you went back in time to 1980 and offered the following choice:

I'll give you a computer that runs 950X faster and doesn't have a huge class of memory safety vulnerabilities, and you can debug your programs orders of magnitude more easily, or you can have a computer that runs 1000X faster and software will be just as buggy, or worse, and debugging will be even more of a nightmare.

People would have their minds blown at 950X. You wouldn't even have to offer 1000X. But guess what we chose...

Personally I think the 1000Xers kinda ruined things for the rest of us.

Cost of cyberattacks globally[1]: O($trillions)

Cost of average data breach[2][3]: ~$4 million

Cost of lost developer productivity: unknown

We're really bad at measuring the secondary effects of our short-sightedness.

[1] https://iotsecurityfoundation.org/time-to-fix-our-digital-fo...

[2] https://www.internetsociety.org/resources/doc/2023/how-to-ta...

[3] https://www.ibm.com/reports/data-breach

Saying "if we did X we'd get a lot in return" is similar to the fallacy of inverting logical implication. The question isn't, will doing something have significant value, but rather, to get the most value, what is the thing we should do? The answer may well be not to make optimisation a priority even if optimisation has a lot of value.

The market mostly didn't want 50% faster code as much as it wanted an app that didn't exist before.

If I look at the apps I use on a day to day basis that are dog slow and should have been optimized (e.g. slack, jira), it's not really a lack of the industry's engineering capability to speed things up that was the core problem, it is just an instance the principal-agent problem - i.e. I'm not the one buying, I don't get to choose not to use it and dog-slow is just one of many the dimensions in which they're terrible.

The software desktop users have to put up with is slow.

No user actually wants abundance. They use few programs and would benwfit if those programs were optimized.

Established apps could be optimized to the hilt.

But they seldom are.

It would be interesting to collect a roadmap for optimizing software at scale -- where is there low hanging fruit? What are the prime "offenders"?

Call it a power saving initiative and get environmentally-minded folks involved.

That could end up being Electron (VS Code), though that would be a bit sad.

https://youtu.be/m7PVZixO35c?si=px2QKP9-80hDV8Ui

I'd bet on maybe ad hoc ai designed ui-s you click but have a voice search when you are confused about something.

No, all users just want the few programs which they themselves need. The market is not one user, though. It's all of them.

The only thing I can think of that’s slow is Autodesk Fusion starting up. Not really sure how they made that so bad but everything else seems super snappy.

The only slow (local) software I know is llvm and cpp compilers

Other are pretty fast

Really? Because while abstractions like that exist (i.e. a webserver frameworks, reactivity, SQL and ORMs etc), I would argue that these aren't the abstractions that cause the most maintenance and performance issues. These are usually in the domain/business application and often not something that made anything quicker to develop or anything, but instead created by a developer that just couldn't help themselves

Somehow the Xcode team managed to make startup and some features in newer Xcode versions slower than older Xcode versions running on old Intel Macs.

E.g. the ARM Macs are a perfect illustration that software gets slower faster than hardware gets faster.

After a very short 'free lunch' right after the Intel => ARM transition we're now back to the same old software performance regression spiral (e.g. new software will only be optimized until it feels 'fast enough', and that 'fast enough' duration is the same no matter how fast the hardware is).

Another excellent example is the recent release of the Oblivion Remaster on Steam (which uses the brand new UE5 engine):

On my somewhat medium-level PC I have to reduce the graphics quality in the Oblivion Remaster so much that the result looks worse than 14-year old Skyrim (especially outdoor environments), and that doesn't even result in a stable 60Hz frame rate, while Skyrim runs at a rock-solid 60Hz and looks objectively better in the outdoors.

E.g. even though the old Skyrim engine isn't by far as technologically advanced as UE5 and had plenty of performance issues at launch on a ca. 2010 PC, the Oblivion Remaster (which uses a "state of the art" engine) looks and performs worse than its own 14 years old predecessor.

I'm sure the UE5-based Oblivion remaster can be properly optimized to beat Skyrim both in looks and performance, but apparently nobody cared about that during development.

Of course, that would be suicide for the industry. But I'm not sure investors see that.

However, you also need to consider 2 additional factors. Macbooks and iPhones, even 4 year old ones, have usually been at the upper end of the scale for processing power. (When compared to the general mass-market of private end-consumer devices)

Try doing the same on a 4 year old 400 Euro laptop and it might look a bit different. Also consider your connection speed and latency. I usually have no loading issue either. But I have a 1G fiber connection. My parents don't.

Life on an entry or even mid level windows laptop is a very different world.

If what we're asking is whether value => X, i.e. to get the most value we should do X, you cannot answer that in the positive by proving X => value. If optimising something is worth a gazillion dollars, you still should not do it if doing something else is worth two gazillion dollars.

Edit: and probably writing backends in Python or Ruby or JavaScript.

What is frustrating though that until relatively recently these devices would work fine with JS heavy apps and work really well with anything that is using a native toolkit.

A few years ago I accidentally left my laptop at work on a Friday afternoon. Instead of going into the office, I pulled out a first generation raspberry pi and got everything set up on that. Needless to say, our nodejs app started pretty slowly. Not for any good reason - there were a couple modules which pulled in huge amounts of code which we didn’t use anyway. A couple hours work made the whole app start 5x faster and use half the ram. I would never have noticed that was a problem with my snappy desktop.

Yes but it's a different 'few programs' than 99% of all other users, so we're back to square one.

Just the clockspeed increased 1000X, from 4 MHz to 4 GHz.

But then you have 10x more cores, 10x more powerful instructions (AVX), 10x more execution units per core.

Here's some software I use all the time, which feels horribly slow, even on a new laptop:

Slack.

Switching channels on slack, even when you've just switched so it's all cached, is painfully slow. I don't know if they build in a 200ms or so delay deliberately to mask when it's not cached, or whether it's some background rendering, or what it is, but it just feels sluggish.

Outlook

Opening an email gives a spinner before it's opened. Emails are about as lightweight as it gets, yet you get a spinner. It's "only" about 200ms, but that's still 200ms of waiting for an email to open. Plain text emails were faster 25 years ago. Adding a subset of HTML shouldn't have caused such a massive regression.

Teams

Switching tabs on teams has the same delayed feeling as Slack. Every iteraction feels like it's waiting 50-100ms before actioning. Clicking an empty calendar slot to book a new event gives 30-50ms of what I've mentally internalised as "Electron blank-screen" but there's probably a real name out there for basically waiting for a new dialog/screen to even have a chrome, let alone content. Creating a new calendar event should be instant, it should not take 300-500ms or so of waiting for the options to render.

These are basic "productivity" tools in which every single interaction feels like it's gated behind at least a 50ms debounce waiting period, with often extra waiting for content on top.

Is the root cause network hops or telemetry? Is it some corporate antivirus stealing the computer's soul?

Ultimately the root cause doesn't actually matter, because no matter the cause, it still feels like I'm wading through treacle trying to interact with my computer.

On the extreme, my retired parents don't feel the difference between 5s or 1s when loading a window or clicking somewhere. I offered a switch to a new laptop, cloning their data, and they didn't give a damn and just opened the laptop the closest to them.

Most people aren't that desensitized, but for some a 600ms delay is instantaneous when for other it's 500ms too slow.

On the website front - Facebook, twitter, Airbnb, Reddit, most news sites, all take 10+ seconds to load or be functional, and their core functionality has regressed significantly in the last decade. I’m not talking about features that I prefer, but as an example if you load two links in Reddit in two different tabs my experience has been that it’s 50/50 if they’ll actually both load or if one gets stuck either way skeletons.

1000x referred to the hardware capability, and that's not a rarity that is here.

The trouble is how software has since wasted a majority of that performance improvement.

Some of it has been quality of life improvements, leading nobody to want to use 1980s software or OS when newer versions are available.

But the lion's share of the performance benefit got chucked into the bin with poor design decisions, layers of abstractions, too many resources managed by too many different teams that never communicate making any software task have to knit together a zillion incompatible APIs, etc.

The "instant" today is really laggy compared to what we had. Opening Slack takes 5s on a flagship phone and opening a channel which I just had open and should be fully cached takes another 2s. When you type in JIRA the text entry lags and all the text on the page blinks just a tiny bit (full redraw). When pages load on non-flagship phones (i.e. most of the world), they lag a lot, which I can see on monitoring dashboards.

Or would bounds checking in fact more than double the time to insert a bunch of ints separately into the array, testing where each one is being put? Or ... is there some gimmick to avoid all those individual checks, I don't know.

I could compare Slack to, say, HexChat (or any other IRC client). And yeah, it’s an unfair comparison in many ways – Slack has far more capabilities. But from another perspective, how many of them do you immediately need at launch? Surely the video calling code could be delayed until after the main client is up, etc. (and maybe it is, in which case, oh dear).

A better example is Visual Studio [0], since it’s apples to apples.

[0]: https://youtu.be/MR4i3Ho9zZY

If you're on Mac, go install Network Link Conditioner and crank that download an upload speed way down. (Xcode > Open Developer Tools > More Developer Tools... > "Additional Tools for Xcode {Version}").

Fairly sure that was OP's point.

Certain ORMs such as Rails's ActiveRecord are part of the problem because they create the illusion that local memory access and DB access are the same thing. This can lead to N+1 queries and similar issues. The same goes for frameworks that pretend that remote network calls are just a regular method access (thankfully, such frameworks seem to have become largely obsolete).

Sonos’ app is a perfect example of this. The old app controlled everything locally, since the speakers set up their own wireless mesh network. This worked fantastically well. Someone at Sonos got the bright idea to completely rewrite the app such that it wasn’t even backwards-compatible with older hardware, and everything is now a remote calls. Changing volume? Phone —> Router —> WAN —> Cloud —> Router —> Speakers. Just… WHY. This failed so spectacularly that the CEO responsible stepped down / was forced out, and the new one claims that fixing the app is his top priority. We’ll see.

On my work machine slack takes five seconds, IDEA is pretty close to instant, the corporate VPN starts nearly instantly (although the Okta process seems unnecessarily slow I'll admit), and most of the sites I use day-to-day (after Okta) are essentially instant to load.

I would say that your experiences are not universal, although snappiness was the reason I moved to apple silicon macs in the first place. Perhaps Intel is to blame.

Reminds me of when NodeJS came out that bridged client and server side coding. And apparently their repos can be a bit of a security nightmare nowadays- so the minimalist languages with limited codebase do have their pros.

I have struggled against this long enough that I don’t think there is an easy fix. My current company is the first I’ve been at that is taking it seriously, and that’s only because we had a spate of SEV0s. It’s still not easy, because a. I and the other technically-minded people have to find the problems, then figure out how to explain them b. At its heart, it’s a culture war. Properly normalizing your data model is harder than chucking everything into JSON, even if the former will save you headaches months down the road. Learning how to profile code (and fix the problems) may not be exactly hard, but it’s certainly harder than just adding more pods to your deployment.

It doesn’t work like that. If an image processing algorithm takes 2 instructions per pixel, adding a check to every access could 3-4x the cost.

This is why if you dictate bounds checking then the language becomes uncompetitive for certain tasks.

The vast majority of cases it doesn’t matter at all - much less than 5%. I think safe/unsafe or general/performance scopes are a good way to handle this.

Both sides are right.

There is a ton of waste and bloat and inefficiency. But there's also a ton of stuff that genuinely does demand more memory and CPU. An incomplete list:

- Higher DPI displays use intrinsically more memory and CPU to paint and rasterize. My monitor's pixel array uses 4-6X more memory than my late 90s PC had in the entire machine.

- Better font rendering is the same.

- Today's UIs support Unicode, right to left text, accessibility features, different themes (dark/light at a minimum), dynamic scaling, animations, etc. A modern GUI engine is similar in difficulty to a modern game engine.

- Encryption everywhere means that protocols are no longer just opening a TCP connection but require negotiation of state and running ciphers.

- The Web is an incredibly rich presentation platform that comes with the overhead of an incredibly rich presentation platform. It's like PostScript meets a GUI library meets a small OS meets a document markup layer meets...

- The data sets we deal with today are often a lot larger.

- Some of what we've had to do to get 1000X performance itself demands more overhead: multiple cores, multiple threads, 64 bit addressing, sophisticated MMUs, multiple levels of cache, and memory layouts optimized for performance over compactness. Those older machines were single threaded machines with much more minimal OSes, memory managers, etc.

- More memory means more data structure overhead to manage that memory.

- Larger disks also demand larger structures to manage them, and modern filesystems have all kinds of useful features like journaling and snapshots that also add overhead.

... and so on.

Perhaps we can blame the 'statistical monetization' policies of adtech and then AI for all this -- i'm not entirely sold on developers.

What, after all, is the difference between an `/etc/hosts` set of loop'd records vs. an ISP's dns -- as far as the software goes?

I suddenly remembered some old Corel Draw version circa year 2005, which had loading screen enumerating random things it loaded and was computing until a final message "Less than a minute now...". It most often indeed lasted less than a minute to show interface :).

Queries I can sometimes rewrite, and there’s nothing more satisfying than handing a team a 99% speed-up with a couple of lines of SQL. Sometimes I can’t, and it’s both painful and frustrating to explain that the reason the dead-simple single-table SELECT is slow is because they have accumulated billions of rows that are all bloated with JSON and low-cardinality strings, and short of at a minimum table partitioning (with concomitant query rewrites to include the partition key), there is nothing anyone can do. This has happened on giant instances, where I know the entire working set they’re dealing with is in memory. Computers are fast, but there is a limit.

The other way the DB gets blamed is row lock contention. That’s almost always due to someone opening a transaction (e.g. SELECT… FOR UPDATE) and then holding it needlessly while doing other stuff, but sometimes it’s due to the dev not being aware of the DB’s locking quirks, like MySQL’s use of gap locks if you don’t include a UNIQUE column as a search predicate. Read docs, people!

Though it’s also unclear to me in this particular case why they couldn’t collect commands being issued, and then batch-send them hourly, daily, etc. instead of having each one route through the cloud.

Anyway, five seconds is long for a text editor; 10, 15 years ago, sublime text loaded and opened up a file in <1 second, and it still does today. Vim and co are instant.

Also keep in mind that desktop computers haven't gotten significantly faster for tasks like opening applications in the past years; they're more efficient (especially the M line CPUs) and have more hardware for specialist workloads like what they call AI nowadays, but not much innovation in application loading.

You use a lot of words like "pretty close to", "nearly", "essentially", but 10, 20 years ago they WERE instant; applications from 10, 20 years ago should be so much faster today than they were on hardware from back then.

I wish the big desktop app builders would invest in native applications. I understand why they go for web technology (it's the crossplatform GUI technology that Java and co promised and offers the most advanced styling of anything anywhere ever), but I wish they invested in it to bring it up to date.

One of the biggest performance issues I witness is that everyone assumes a super fast, always on WiFi/5G connection. Very little is cached locally on device so even if I want to do a very simple search through my email inbox I have to wait on network latency. Sometimes that’s great, often it really isn’t.

Same goes for many SPA web apps. It’s not that my phone can’t process the JS (even though there’s way too much of it), it’s poor caching strategies that mean I’m downloading and processing >1MB of JS way more often than I should be. Even on a super fast connection that delay is noticeable.

I'm sure it's significantly more expensive to render than Windows 3.11 - XP were - rounded corners and scalable vector graphics instead of bitmaps or whatever - but surely not that much? And the resulting graphics can be cached.

Animations is part of it of course. A lot of old software just updates the screen immediately, like in a single frame, instead of adding frustrating artificial delays to every interaction. Disabling animations in Android (an accessibility setting) makes it feel a lot faster for instance, but it does not magically fix all apps unfortunately.

Would we? Really? I don't think giving up performance needs to be a compromise for the number of features or speed of delivering them.

IPC could be 80x higher when taking into account SIMD and then you have to multiply by each core. Mainstream CPUs are more like 1 to 2 million times faster than what was there in the 80s.

You can get full refurbished office computers that are still in the million times faster range for a few hundred dollars.

The things you are describing don't have much to do with computers being slow and feeling slow, but they are happening anyway.

Scripting languages that are constantly allocating memory to any small operation and pointer chasing ever variable because the type is dynamic is part of the problem, then you have people writing extremely inefficient programs in an already terrible environment.

Most programs are written now in however way the person writing them wants to work, not how someone using it wishes they were written.

Most people have actually no concept of optimization or what runs faster than something else. The vast majority of programs are written by someone who gets it to work and thinks "this is how fast this program runs".

The idea that the same software can run faster is a niche thought process, not even everyone on hacker news thinks about software this way.

I don't think I ever used a human for that. They are usually very uninformed about everything that's not their standard operational procedure or some current promotional materials.

The art direction, modelling and animation work is mostly fine, the worse look results from the lack of dynamic lighting and ambient occlusion in the Oblivion Remaster when switching Lumen (UE5's realtime global illumination feature) to the lowest setting, this results in completely flat lighting for the vegetation but is needed to get an acceptable base frame rate (it doesn't solve the random stuttering though).

Basically, the best art will always look bad without good lighting (and even baked or faked ambient lighting like in Skyrim looks better than no ambient lighting at all.

Digital Foundry has an excellent video about the issues:

https://www.youtube.com/watch?v=p0rCA1vpgSw

TL;DR: the 'ideal hardware' for the Oblivion Remaster doesn't exist, even if you get the best gaming rig money can buy.

This is absolutely remarkable inefficiency considering the application's core functionality (media players) was perfected a quarter century ago.

So very rarely should it be anything like 3-4x the cost, though some complex indexing could cause it to happen, I suppose. I agree scopes are a decent way to handle it!

This also happens to many other UE5 games like S.T.A.L.K.E.R. 2 where they try to push the graphics envelope with expensive techniques and most people without expensive hardware have to turn the settings way down (even use things like upscaling and framegen which further makes the experience a bit worse, at least when the starting point is very bad and you have to use them as a crutch), often making these modern games look worse than something a decade old.

Whatever UE5 is doing (or rather, how so many developers choose to use it) is a mistake now and might be less of a mistake in 5-10 years when the hardware advances further and becomes more accessible. Right now it feels like a ploy by the Big GPU to force people to upgrade to overpriced hardware if they want to enjoy any of these games; or rather, sillyness aside, is an attempt by studios to save resources by making the artists spend less time on faking and optimizing effects and detail that can just be brute forced by the engine.

In contrast, most big CryEngine and idTech games run great even on mid range hardware and still look great.

Says who? Who are these experienced people that know how to write fast software that think it is such a huge sacrifice?

The reality is that people who say things like this don't actually know much about writing fast software because it really isn't that difficult. You just can't grab electron and the lastest javascript react framework craze.

These kinds of myths get perpetuated by people who repeat it without having experienced the side of just writing native software. I think mostly it is people rationalizing not learning C++ and sticking to javascript or python because that's what they learned first.

Do any of those do the indexing that cause the slowness? If not it's comparing apples to oranges.

Why stop at C++? Is that what you happen to be comfortable with? Couldn't you create even faster software if you went down another level? Why don't you?

Worse, the document strained my laptop so much as I used it, I regularly had to reload the web-page.

I have to stay connected to VPN to work, and if I see VPN is not connected I click to reconnect.

If the VPN button hasn't loaded you end up turning on Airplane mode. Ouch.

I see this all the time with people who have old computers.

“My computer is really fast. I have no need to upgrade”

I press cmd+tab and watch it take 5 seconds to switch to the next window.

That’s a real life interaction I had with my parents in the past month. People just don’t know what they’re missing out on if they aren’t using it daily.

No and if you understood what makes software fast you would know that. Most software is allocating memory inside hot loops and taking that out is extremely easy and can easily be a 7x speedup. Looping through contiguous memory instead of chasing pointers through heap allocated variables is another 25x - 100x speed improvement at least. This is all after switching from a scripting language, which is about a 100x in itself if the language is python.

It isn't about the instructions it is about memory allocation and prefetching.

A lot of other native Mac stuff is also less than ideal. Terminal keeps getting stuck all the time, Mail app can take a while to render HTML emails, Xcode is Xcode, and so on.

This is kind of been a disappointment to me of AI when I've tried it. This has kind of been a disappointment to me of AI when I've tried it. Llm should be able to Port things. It should be able to rewrite things with the same interface. It should be able to translate from inefficient languages to more efficient ones.

It should even be able to optimize existing code bases automatically, or at least diagnose or point out poor algorithms, cache optimization, etc.

Heck I remember powerbuilder in the mid 90s running pretty well on 200 mhz CPUs. It doesn't even really interpreted stuff. It's just amazing how slow stuff is. Do rounded corners and CSS really consume that much CPU power?

My limited experience was trying to take the unix sed source code and have AI port it into a jvm language, and it could do the most basic operations, but utterly failed at even the intermediate sed capabilities. And then optimize? Nope

Of course there's no desire for something like that. Which really shows what the purpose of all this is. It's to kill jobs. It's not to make better software. And it means AI is going to produce a flood of bad software. Really bad software.

I'm so dumbfounded. Maybe non-MacOS, non-Apple silicon stuff is complete crap at that point? Maybe the complete dominance of Apple performance is understated?

Why not log them to a file and cron a script to upload the data? Even if the feature request is nonsensical, you can architect a solution that respect the platform's constraints. It's kinda like when people drag in React and Next.js just to have a static website.

You are probably a lazy or inexperienced engineer if you choose to work in C++.

In fact, there are optimizations available at the silicon level that are not available in assembly.

You are probably a lazy or inexperienced engineer if you choose to work in assembly.

And FWIW this stuff is then cached. I hadn't clicked that setting area in a while (maybe the first time this boot?) and did get a brief gray box that then a second later populated with all the buttons and settings. Now every time I click it again it appears instantly.

Maybe if you're in a purely text console doing purely text things 100% in memory it can feel snappy. But the moment you do anything graphical or start working on large datasets its so incredibly slow.

I still remember trying to do photo editing on a Pentium II with a massive 64MB of RAM. Or trying to get decent resolutions scans off a scanner with a Pentium III and 128MB of RAM.

Running latest Outlook on Windows 11, currently >1k emails in my Inbox folder, on an 11th gen i5, while also on a Teams call a ton of other things active on my machine.

This is also a machine with a lot of corporate security tools sapping a lot of cycles.

For comparison: https://www.cpubenchmark.net/compare/1075vs5852/Intel-Pentiu...

That's about a 168x difference. That was from before Moores law started petering out.

For only a 5x speed difference you need to go back to the 4th or 5th generation Intel Core processors from about 10 years ago.

It is important to note that the speed figure above is computed by adding all of the cores together and that single core performance has not increased nearly as much. A lot of that difference is simply from comparing a single core processor with one that has 20 cores. Single core performance is only about 8 times faster than that ancient Pentium 4.

My corporate vpn app is a disaster on so many levels, it’s an internally developed app as opposed to Okta or anything like that.

I would likewise say that your experience is not universal, and that in many circumstances the situation is much worse. My wife is running an i5 laptop from 2020 and her work intranet is a 60 second load time. Outlook startup and sync are measured in minutes including mailbox fetching. You can say this is all not the app developers fault, but the crunch that’s installed on her machine is slowing things down by 5 or 10x and that slowdown wouldn’t be a big deal if the apps had reasonable load times in the first place.

I have no corp antivirus or MDM on this machine, just windows 11 and windows defender.

You're going to have to cite a source for that.

Bounds checking is one mechanism that addresses memory safety vulnerabilities. According to MSFT and CISA[1], nearly 70% of CVEs are due to memory safety problems.

You're saying that we shouldn't solve one (very large) part of the (very large) problem because there are other parts of the problem that the solution wouldn't address?

[1] https://www.cisa.gov/news-events/news/urgent-need-memory-saf...

[0] https://x.com/ryanjfleury/status/1747756219404779845

There's native apps just as, if not more, complicated than VSCode that open faster.

The real problem is electron. There's still good, performant native software out there. We've just settled on shipping a web browser with every app instead.

The problem is when you load it and then react and all its friends, and design your software for everything to be asynchronous and develop it on a 0 latency connection over localhost with a team of 70 people where nobody is holistically considering “how long does it take from clicking the button to doing the thing I want it to do”

I don't use Slack, but I don't think anything takes 20 seconds for me. Maybe XCode, but I don't use it often enough to be annoyed.

But...why? Why on earth do I need 16 gigs of memory for web browsing and basic application use? I'm not even playing games on this thing. But there was an immediate, massive spike in performance when I upgraded the memory. It's bizarre.

Same thing happens with UI & Website design. When the designers and front-end devs all have top-spec MacBooks, with 4k+ displays, they design to look good in that environment.

Then you ship to the rest of the world which are still for the most part on 16:9 1920x1080 (or god forbid, 1366x768), low spec windows laptops and the UI looks like shit and is borderline unstable.

Now I don't necessarily think things should be designed for the lowest common denominator, but at the very least we should be taking into consideration that the majority of users probably don't have super high end machines or displays. Even today you can buy a brand new "budget" windows laptop that'll come with 8GB of RAM, and a tiny 1920x1080 display, with poor color reproduction and crazy low brightness - and that's what the majority of people are using, if they are using a computer at all and not a phone or tablet.

It's electron. Electron was a mistake.

My older computers would completely lock up when given a large task to do, often for many seconds. Scanning an image would take over the whole machine for like a minute per page! Applying a filter to an image would lock up the machine for several seconds even for a much smaller image a much simpler filter. The computer cannot even play mp3's and have a responsive word processor, if you really want to listen to music while writing a paper you better have it pass through the audio from a CD, much less think about streaming it from some remote location and have a whole encrypted TCP stream and decompression.

These days I can have lots of large tasks running at the same time and still have more responsiveness.

I have fun playing around with retro hardware and old applications, but "fast" and "responsive" are not adjectives I'd use to describe them.

Today a website is easier. But just like there's a very large percentage of people doing a great many things from their phone instead of tying themselves to a full-blown personal computer, there will be an increasing number of people who send their agents off to get things done. In that scenario, the user interface is further up the stack than a browser, if there's a browser as typically understood in the stack at all.

I remember that UE4 also hyped a realtime GI solution which then was hardly used in realworld games because it had a too big performance hit.

If you haven't compared high and low latency directly next to each other then there are good odds that you don't know what it looks like. There was a twitter video from awhile ago that did a good job showing it off that's one of the replies to the OP. It's here: https://x.com/jmmv/status/1671670996921896960

Sorry if I'm too presumptuous, however; you might be completely correct and instant is instant in your case.

The eye percieves at about 10 hz. That's 100ms per capture. All the rest, I'd have to see a study that shows how any higher framerate can possibly be perceived or useful.

I'm with the person you're responding. I use the regular suite of applications and websites on my 2021 M1 Macbook. Things seem to load just fine.

( This might also be a "new outlook" vs "out outlook" thing? )

You add a new layer of indirection to fix that one problem on the previous layer, and repeat it ad infinitum until everyone is complaining about having too many layers of indirection, yet nobody can avoid interacting with them, so the only short-term solution is a yet another abstraction.

It's a mix of better CPUs, better OS design (e.g. much less need for aggressive virus scanners), a faster filesystem, less corporate meddling, high end SSDs by default... a lot of things.

I don't doubt it's happening to you, but I've never experienced it. And I'm not exactly using bleeding edge hardware here. A several year old i5 and a Ryzen 3 3200U (a cheap 2019 processor in a cheap Walmart laptop).

Maybe your IT team has something scanning every email on open. I don't know what to tell you, but it's not the experience out of the box on any machine I've used.

How long did it take the last time you had to use an HDD rather than SSD for your primary drive?

How long did it take the first time you got to use an SSD?

How long does it take today?

Did literally anything other than the drive technology ever make a significant difference in that, in the last 40 years?

> Almost everything loads instantly on my 2021 MacBook

Instantly? Your applications don't have splash screens? I think you've probably just gotten used to however long it does take.

> 5 year old mobile CPUs load modern SPA web apps with no problems.

"An iPhone 11, which has 4GB of RAM (32x what the first-gen model had), can run the operating system and display a current-day webpage that does a few useful things with JavaScript".

This should sound like clearing a very low bar, but it doesn't seem to.

It takes effectively no effort to conduct such a study yourself. Just try re-encoding a video at different frame rates up to your monitor refresh rate. Or try looking at a monitor that has a higher refresh rate than the one you normally use.

It's the sort of thing that can be handled via better libraries, if people use them. Instead of Hibernate use a mapper like Micronaut Data. Turn on roundtrip diagnostics in your JDBC driver, look for places where they can be eliminated by using stored procedures. Have someone whose job is to look out for slow queries and optimize them, or pay for a commercial DB that can do that by itself. Also: use a database that lets you pipeline queries on a connection and receive the results asynchronously, along with server languages that make it easy to exploit that for additional latency wins.

Anyway that's a form of saying "I know by reasoning that none of these will be outside the bounds, so let's not check".

And even if every information takes a bit to figure out, it doesn't excuse taking a second to even draw the UI. If checking bluetooth takes a second, then draw the button immediately but disable interaction and show a loading icon, and when you get the blutooth information update the button, and so on for everything else.

And OK, we'll draw a tile with all the buttons with greyed out status for that half second and then refresh to show the real status. Did that really make things better, or did it make it worse?

And if we bothered keeping all that in memory, and kept using the CPU cycles to make sure it was actually accurate and up to date on the click six hours later, wouldn't people then complain about how obviously bloated it was? How is this not a constant battle of being unable to appease any critics until we're back at the Win 3.1 state of things with no Bluetooth devices, no WiFi networks, no dynamic changing or audio devices, etc?

And remember, we're comparing this to just rendering a volume slider which still took a similar or worse amount of time and offered far less features.

Clearly better. Most of the buttons should also work instantly, most of the information should also be available instantly. The button layout is rendered instantly, so I can already figure out where I want to click without having to wait one second even if the button is not enabled yet, and by the time my mouse reaches it it will probably be enabled.

> And remember, we're comparing this to just rendering a volume slider which still took a similar or worse amount of time and offered far less features.

I've never seen the volume slider in Windows 98 take one second to render. Not even the start menu, which is much more complex, and which in Windows 11 often takes a second, and search results also show up after a random amount of time and shuffle the results around a few times, leading to many misclicks.

And if you don't remember the volume slider taking several seconds to render on XP you must be much wealthier than me or have some extremely rose colored glasses. I play around with old hardware all the time and get frustrated with the unresponsiveness of old equipment with period accurate software, and had a lot of decent hardware (to me at least) in the 90s and 00s. I've definitely experienced lots of times of the start menu painting one entry after the other at launch, taking a second to roll out, seeking on disk for that third level menu in 98, etc.

Rose colored glasses, the lot of you. Go use an old 386 for a month. Tell me how much more productive you are after.

This is a theoretical argument. It depends on the compiler being able to see that’s what you’re doing and prove that there is no other mutation.

> abominations of C and C++

Sounds like you don’t understand the design choices that made this languages successful.

I'm sure some of these people are using 10 year old corporate laptops with heavy corporate anti-virus scanning, leading to slow startup times. However, I think a lot of people are just exaggerating. If it's not instantly open, it's too long for them.

I, too, can get programs like Slack and Visual Studio Code to launch in a couple seconds at most, in contrast to all of these comments claiming 20 second launch times. I also don't quit these programs, so the only time I see that load time is after an update or reboot. Even if every program did take 20 seconds to launch and I rebooted my computer once a week, the net time lost would be measured in a couple of minutes.

> On the website front - Facebook, twitter, Airbnb, Reddit, most news sites, all take 10+ seconds to load or be functional

I just launched IntelliJ (first time since reboot). Took maybe 2 seconds to the projects screen. I clicked a random project and was editing it 2 seconds after that.

I tried Twitter, Reddit, AirBnB, and tried to count the loading time. Twitter was the slowest at about 3 seconds.

I have a 4 year old laptop. If you're seeing 10 second load times for every website and 20 second launch times for every app, you have something else going on. You mentioned corporate VPN, so I suspect you might have some heavy anti-virus or corporate security scanning that's slowing your computer down more than you expect.

Click latency of the fastest input devices is about 1ms and with a 120Hz screen you're waiting 8.3ms between frames. If someone is annoyed by 10ms of latency they're going to have a hard time in the real world where everything takes longer than that.

I think the real difference is that 1-3 seconds is completely negligible launch time for an app when you're going to be using it all day or week, so most people do not care. That's effectively instant.

The people who get irrationally angry that their app launch took 3 seconds out of their day instead of being ready to go on the very next frame are just never going to be happy.

Your understanding of how bounds checking works in modern languages and compilers is not up to date. You're not going to find a situation where bounds checking causes an algorithm to take 3-4X longer.

A lot of people are surprised when the bounds checking in Rust is basically negligible, maybe 5% at most. In many cases if you use iterators you might not see a hit at all.

Then again, if you have an image processing algorithm that is literally reading every single pixel one-by-one to perform a 2-instruction operation and calculating bounds check on every access in the year 2025, you're doing a lot of things very wrong.

> This is why if you dictate bounds checking then the language becomes uncompetitive for certain tasks.

Do you have any examples at all? Or is this just speculation?

One I am familiar with is Swift - which does exactly this because it’s a library feature of Array.

Which languages will always be able to determine through function calls, indirect addressing, etc whether it needs to bounds check or not?

And how will I know if it succeeded or whether something silently failed?

> if you have an image processing algorithm that is literally reading every single pixel one-by-one to perform a 2-instruction operation and calculating bounds check on every access in the year 2025, you're doing a lot of things very wrong

I agree. And note this is an example of a scenario you can encounter in other forms.

> Do you have any examples at all? Or is this just speculation?

Yes. Java and python are not competitive for graphics and audio processing.

Robert Barton (of Burroughs 5000 fame) once referred to these people as “high priests of a low cult.”

Even your average movie captures at 24 hz. Again, very likely you've never actually just compared these things for yourself back to back, as I mentioned originally.

So the quality has gone backwards in the process of rewriting the app into the touch friendly style. A lot of core windows apps are like that.

Note that the windows file system is much slower than the linux etx4, I don't know about Mac filesystems.

I'm talking about speeding software up by 10x-100x by language choice, then 7x with extremely minimal adjustments (allocate memory outside of hot loops), then 25x - 100x with fairly minimal design changes (use vectors, loop through them straight).

I'm also not saying people are lazy, I'm saying they don't know that with something like modern C++ and a little bit of knowledge of how to write fast software MASSIVE speed gains are easy to get.

You are helping make my point here, most programmers don't realize that huge speed gains are low hanging fruit. They aren't difficult, they don't mean anything is contorted or less clear (just the opposite), they just have to stop rationalizing not understanding it.

I say this with knowledge of both sides of the story instead of guessing based on conventional wisdom.

I recently watched a video that can be summarised quite simply as: "Computers today aren't that much faster than the computers of 20 years ago, unless you specifically code for them".

https://www.youtube.com/watch?v=m7PVZixO35c

It's a little bit ham-fisted, as the author was shirking decades of compile optimisations also, and it's not apples to apples as he's comparing desktop class hardware with what is essentially laptop hardware; but it's also interesting to see that a lot of the performance gains really weren't that great actually. he observes a doubling of performance in 15 years! Truth be told most people use laptops now, and truth be told 20 years ago most people used desktops, so it's not totally unfair.

Maybe we've bought a lot into marketing.

Garbage collected languages often consume several times as much memory. They aren't immediately freeing memory no longer being used, and generally require more allocations in the first place.

Modern C++ and systems language didn't exist and neither was made with the intention that people would write general purpose interactive programs that leveraged computers 1,000x faster so that software could run 1,000x slower.

I (very recently I might add) used a Razer Blade 18, with i9 13950HX and 64G of DDR5 memory, and it felt awfully slow, not sure how much of that is Windows 11's fault however.

My daily driver is an M2 Macbook Air (or a Threadripper 3970x running linux); but the workers in my office? Dell Latitudes with an i5, 4 real cores and 16G of RAM if they're lucky... and of course, Windows 11.

Don't even ask what my mum uses at home, it cost less than my monthly food bill; and that's pretty normal for people who don't love computers.

You agree with my original point then?

(Yes, I've tried all combinations of software to hardware and accounted for all known factors, it's not caused by viruses or antiviruses).

XP was the last really responsive Microsoft OS, it went downhill from then and never recovered.

Ugh, I personally witnessed this. I would wait to take my break until I knew the unavoidable, unkillable AV scans had started and would peg my CPU at 100%. I wonder how many human and energy resources are wasted checking for non-existant viruses on corp hardware.

Writing dramatically fast software that is 1,000x or even 10,000 times faster than a scripting language takes basically zero effort once you know how to do it and these assembly optimization are a myth that you would have already shown me if you could.

Congratulations you’ve discovered the value of abstractions!

I mean, you’re the one who started this off with the insane claim that there’s no tradeoff, then claimed there are no optimizations available below C++ (i.e. C++ is the absolute most optimized code a person can write). Not my fault you stake out indefensible positions.

I still think there’s a lot of blame to go around for the “kitchen sink” approach to app development where we have entire OS’s that can boot faster than your app can get off a splash screen.

Unfortunately, my users are on windows and work has no Linux vpn client so a switch isn’t happening any time soon.

I have a 12 core Ryzen 9 with 64GB of RAM, and clicking the emoji reaction button in Signal takes long enough to render the fixed set of emojis that I've begun clicking the empty space where I know the correct emoji will appear.

For years I've been hitting the Windows key, typing the three or four unique characters for the app I want and hitting enter, because the start menu takes too long to appear. As a side note, that no longer works since Microsoft decided that predictability isn't a valuable feature, and the list doesn't filter the same way every time or I get different results depending on how fast I type and hit enter.

Lots of people literally outpace the fastest hardware on the market, and that is insane.

Zotero would take 30 seconds to a minute to start up. papis has no startup time as it's a cli app and searching is nearly instantaneous.

There is no reason for Zotero to be so slow. In fact, before switching I had to cut down on the number of papers it was managing because at one point it stopped loading altogether.

It's great you haven't run into poorly optimized software, but but not everyone is so lucky.

[1]: https://www.zotero.org/ [2]: https://github.com/papis/papis

On my home PC, in 4 seconds I could download 500MB, load 12GB off an SSD, perform 12 billion cycles (before pipelining ) per core (and I have 24 of them) - and yet miro still manages to bring my computer to its knees for 15 seconds just to load an empty whiteboard.

11 years ago I put in a ticket to slack asking them about their resource usage. Their desktop app was using more memory than my IDE and compilers and causing heap space issues with visual studio. 10 years ago things were exactly the same. 15 years ago, my coworkers were complaining that VS2010 was a resource hog compared to 10 years ago. My memory of loading photoshop in the early 2000’s was that it took absolutely forever and was slow as molasses on my home PC.

I don’t think it’s necessarily gotten worse, I think it’s always been pathetically bad.

Also, you could keep the status accurate because it only needs to update on change events anyway, events that happen on "human time" (e.g. you plugged in headphones or moved to a new network location) last for a practical eternity in computer time, and your pre-loaded icon probably takes a couple kB of memory.

It seems absurd to me that almost any UI should fail to hit your monitor's refresh rate as its limiting factor in responsiveness. The only things that make sense for my computer to show its age are photo and video editing with 50 MB RAW photos and 120 MB/s (bytes, not bits) video off my camera.

I explained to you exactly why this is true, and it's because writing fast software just means doing some things slightly differently with a basic awareness of what makes programs fast, not because it is difficult or time consuming. Most egregiously bad software is probably not even due to optimization basics but from recomputing huge amounts of unnecessary results over and over.

What you said back is claims but zero evidence or explanation of anything. You keep talking about assembly language, but it has nothing to do with getting huge improvements for no time investment, because things like instruction count are not where the vast majority of speed improvements come from.

I mean, you’re the one who started this off with the insane claim that there’s no tradeoff, then claimed there are no optimizations available below C++ (i.e. C++ is the absolute most optimized code a person can write).

This is a hallucination that has nothing to do with your original point. The vast majority of software could be sped up 100x to 1000x easily if they were written slightly different. Asm optimizations are extremely niche with modern CPUs and compilers and the gains are minuscule compared to C++ that is already done right. This is an idea that permeates through inexperienced programmers, that asm is some sort of necessity for software that runs faster than scripting languages.

Go ahead and show me what specifically you are talking about with C++, assembly or any systems language or optimization.

Show me where writing slow software saves someone so much time, show me any actual evidence or explanation of this claim.

Even so you haven't provided any compelling evidence that C or C++ made it's decisions to be more appealing or more popular.

That's a fairly worthless metric. What you want is "Cost of cyberattacks / Revenue from attacked systems."

> We're really bad at measuring the secondary effects of our short-sightedness.

We're really good at it. There's an entire industry that makes this it's core competency... insurance. Which is great because it means you can rationalize risk. Which is also scary because it means you can rationalize risk.

It's like how Wi-Fi drivers would cause lag from querying their status, lots of poorly designed drivers and archaic frameworks for them to plug in.

And I doubt any hardware you had when Wolfenstein:ET came out rendered the game that fast. I remember it running at less than 60fps back in '03 on my computer. So slow, poorly optimized, I get better frame rates in Half Life. Why would anyone write something so buggy, unoptimized, and slow?!

IIRC it ran at 76 fps (higher than monitor refresh, one of the locally optimal frame rates for move speed/trick jumps) for me back then on something like an GeForce FX 5200? As long as you had a dedicated GPU it could hit 60 just fine. I think it could even hit 43 (another optimal rate) on an iGPU, which were terrible back then.

In any case, modern software can't even hit monitor refresh latency on modern hardware. That's the issue.

And then doing the same for Bluetooth.

And then doing the same for screen rotation and rotation lock settings. And sound settings, And then another set of settings. And another set of settings. All from different places of the system configuration while still having the backwards compatibility of all those old systems.

It's not a slowness on painting it. It can do that at screen refresh rates no problem. It's a question of querying all these old systems which often result in actual driver queries to get the information.

43fps? Sure sounds slow to me. Why not 333fps on that hardware? So bloated, so slow.

And yes it should cache that info. We're talking bytes. Less than 0.0001% of the available memory.

Things were different on old hardware because old hardware was over 1000x slower. On modern hardware, you should expect everything to be instantaneous.

Shower thoughts include whether there are languages that have features, other than through their popularity and representation in training corpuses, help us get from natural language to efficient code?

I was recently playing around with a digital audio workstation (DAW) software package called Reaper that honestly surprised me with its feature set, portability (Linux, macOS, Windows), snappiness etc. The whole download was ~12 megabytes. It felt like a total throwback to the 1990s in a good way.

It feels like AI should be able to help us get back to small snappy software, and in so doing maybe "pay its own way" with respect to CPU and energy requirements. Spending compute cycles to optimize software deployed millions of times seems intuitively like a good bargain.

Sometimes the devices and drivers just suck. Sometimes it's not the software's fault it's running at 43fps.

I'm hitting the little quick settings area on my exceptionally cheap and old personal laptop. I haven't experienced that slowness once. Once again I imagine the other stuff running interrupting all the OS calls and what not loading this information causes it to be slow.

https://www.pcworld.com/article/2651749/office-is-too-slow-s...

You say snappy, but what is snappy? I right now have a toy project in progress in zig that uses users perception as a core concept.

Rarely one can react to 10ms jank. But when you get to bare metal development 10ms becomes 10 million of reasonably high level instructions that can be done. Now go to website, click. If you can sense a delay from JS this means that jank is approximately 100ms; does clicking that button, really should be 100 million instructions?

When you look close enough you will find that not only it’s 100 million instructions but your operating system along with processor made tens of thousands of tricks in the background to minimize the jank and yet you still can sense it.

Today even writing in non optimized, unpopular languages like Prolog is viable because hardware is mindblowing fast, and yet some things are slow, because we utilize that speed to decrease development costs.

All of Microsoft's suite is garbage. Outlook, Visual Studio, OneNote.

Edge isn't slow, (shockingly) but you know what is? Every webpage. The average web page has 200 dependencies it needs to load--frameworks, ads, libraries, spyware--and each of those dependencies has a 99% latency of 2 seconds, which means on average, at least two of those dependencies takes 2 seconds to load, and the page won't load until they do.

Steam is slow as balls. It's 2025 and it's a 32 bit application for some reason.

At my day job, our users complain that our desktop application is slow. It is slow. We talk about performance a lot and how it will be a priority and it's important. Every release, we get tons of new features, and the software gets slower.

My shit? My shit's fast. My own tiny little fiefdom in this giant rat warrens is fast. It could be faster, but it's pretty fast. It's not embarrassing. When I look at a flamegraph of our code when my code is running, I really have to dig in to find where my code is taking up time. It's fine. I'm--I don't feel bad. It's fine.

I love this industry. We are so smart. We are so capable of so many amazing things. But this industry annoys me. We so rarely do any of them. We're given a problem, and the solution is some god forsaken abomination of an electron app running javascript code on the desktop and pumping bytes into and out of a fucking DOM. The most innovative shit we can come up with is inventing a virtual dumbass and putting it into everything. The most value we create is division, hate, fear, and loathing on social media.

I'm not mad. I'm just disappointed.

Buy something for half that price or less, like most people would be able to, and see if you can still get the same results.

This is also why I'd recommend people with lower budgets to buy high-end second hand rather than recent mid/low tier hardware.

A clean XP install in a VM for nostalgia's sake is fine, but XP as actually used by people for a while quickly ground to a halt because of all the third party software you needed.

The task bar was full of battery widgets, power management icons, tray icons for integrated drivers, and probably at least two WiFi icons, and maybe two Bluetooth ones as well. All of them used different menus that are slow in their own respect, despite being a 200KiB executable that looks like it was written in 1995.

And the random crashes, there were so many random crashes. Driver programmes for basic features crashed all the time. Keeping XP running for more than a day or two by using sleep mode was a surefire way to get an unusual OS.

Modern Windows has its issues but the olden days weren't all that great, we just tolerated more bullshit.

https://xkcd.com/1205/

Just today, I was thinking about the slow load times of a bloated Drupal site that heard partially attributable to a YouTube embed. I then found this, which claims to give a 224x performance increase over YouTube’s stock embed (and shame on YouTube for not improving it):

https://github.com/paulirish/lite-youtube-embed

In the past, I have written electron applications (I had tried Qt first, but had trouble figuring out how what I wanted after 20 hours of trying, and got what I needed from electron in 10). The electron applications are part of appliances that are based on the Raspberry Pi CM4. The electron application loads in a couple seconds on the CM4 (and less than 1 second on my desktop). Rather than using the tools web developers often use that produce absurd amounts of HTML and JS, I wrote nearly every line of HTML and JavaScript by hand (as I would have done 25 years ago) such that it was exactly what I needed and there was no waste. I also had client side JavaScript code running asynchronously after the page loaded. To be fair, I did use a few third party libraries like express and an on screen keyboard, but they were relatively light weight ones.

Out of curiosity, I did a proof of concept port of one application from electron to WebKitGTK with around 100 lines of C. The proof of concept kept nodejs running as a local express server that was accessed by the client side JavaScript running in the WebKitGTK front end via HTTP requests. This cut memory usage in half and seemed to launch slightly faster (although I did not measure it). I estimated that memory usage would be cut in half again if I rewrote the server side JavaScript in C. Memory usage would likely have dropped even more and load times would have become even quicker if I taught myself how to use a GUI toolkit to eliminate the need for client side HTML and JavaScript, but I had more important things to do than spend many more hours to incrementally improve what already worked (and I suspect many are in the same situation).

To give a final example, I had a POSIX shell script that did a few tasks, such as polling a server on its LAN for configuration updates to certain files and doing HA failover of another system were down, among other things. I realized the script iterated too slowly, so I rewrote it to launch a subshell as part of its main loop that does polling (with file locking to prevent multiple sub shells from doing polling at the same time). This allowed me to guarantee HA failover always happens within 5 seconds of another machine going down, and all it took were using concepts from C (threading and locking). They were not as elegant as actual C code (since subshells are not LWPs and thus need IPC mechanisms like file locks), but they worked. I know polling is inefficient, but it is fairly foolproof (no need to handle clients being offline when it is time for a push), robustness was paramount and development time was needed elsewhere.

In any case, using C (or if you must, C++) is definitely better than a scripting language, provided you use it intelligently. If you use techniques from high performance C code in scripting languages, code written in them often becomes many times faster. I only knew how to do things in other languages relatively efficiently because I was replicating what I would be doing in C (or if forced, C++). If I could use C for everything, I would, but I never taught myself how to do GUIs in C, so I am using my 90s era HTML skills as a crutch. However, reading this exchange (and writing this reply) has inspired me to make an effort to learn.

Nintendo comes up with a working game first and then adds the story - BotW/TotK are post-apocalyptic so they don't have to show you too many people on screen at once.

The other way you can tell this is that both games have the same story even though one is a sequel! Like Ganon takes over the castle/Hyrule and then Link defeats him, but then they go into the basement and somehow Ganon is there again and does the exact same thing again? Makes no sense.

I am annoyed at the startup time of programs that I keep closed and only open infrequently (Discord is one of those, the update loop takes a buttload of time because I don't use it daily), but I'm not annoyed when something I keep open takes 1-10s to open.

But when I think of getting annoyed it's almost always because an action I'm doing takes too long. I grew up in an era with worse computers than we have today, but clicking a new list was perceptibly instant- it was like the computer was waiting for the screen to catch up.

Today, it feels like the computer chugs to show you what you've clicked on. This is especially true with universal software, like chat programs, that everyone in an org is using.

I think Casey Muratori's point about the watch window in visual studio is the right one. The watch window used to be instant, but someone added an artificial delay to start processing so that the CPU wouldn't work when stepping fast through the code. The result is that, well, you gotta wait for the watch window to update... Which "feels bad".

https://www.youtube.com/watch?v=GC-0tCy4P1U

1. Scammer Payback and others are documenting on-going attacks that involve social engineering that are not getting the attention that they deserve.

2. You did not provide any actual data on the degree to which bounds checks are “large”. You simply said they were because they are a subset of a large group. There are diseases that only affect less than 100 people in the world that do not get much attention. You could point out that the people affected are humans, which is a group that consists of all people in the world. Thus, you can say that one of these rare diseases affects a large number of people and thus should be a priority. At least, that is what you just did with bounds checks. I doubt that they are as rare as my analogy would suggest, but the point is that the percentage is somewhere between 0 and 70% and without any real data, your claim that it is large is unsubstantiated. That being said, most C software I have touched barely uses arrays for bound checks to be relevant, and when it does use arrays, it is for strings. There are safe string functions available for use like strlcpy() and strlcat() that largely solve the string issues by doing bounds checks. Unfortunately, people keep using the unsafe functions like strcpy() and strcat(). You would have better luck if you suggested people use safe string handling functions rather than suggest compilers insert bounds checks.

3. Your link mentions CHERI, which a hardware solution for this problem. It is a shame that AMD/Intel and ARM do not modify their ISAs to incorporate the extension. I do not mean the Morello processor, which is a proof of concept. I mean the ISA specifications used in all future processors. You might have more luck if you lobby for CHERI adoption by those companies.

Even worse, our bottom most abstraction layers pretend that we are running on a single core system from the 80s. Even Rust got hit by that when it pulled getenv from C instead of creating a modern and safe replacement.

> that asm is some sort of necessity for software that runs faster than scripting languages.

It seems you're not tracking the flow of the conversation if you believe this is what I'm saying. I am saying there is always a way to make things faster by sacrificing other things developer productivity, feature sets, talent pool, or distribution methods. You agree with me, it turns out!

I routinely have shy of 100 network interfaces active and `ip a` is able to query everything in nanoseconds.

Aside from the seminal discussion about text input latency from Dan Luu[0] there's very little we can do to disprove anything right now.

Back in the day asking my computer to "do" something was the thing I always dreaded, I could navigate, click around, use chat programs like IRC/ICQ and so on, and everything was fine, until I opened a program or "did" something that caused the computer to think.

Now it feels like there's no distinction between using a computer and asking it to do something heavy. The fact that I can't hear the harddisk screaming or the fan spin up (and have it be tied to something I asked the computer to do) might be related.

It becomes expectation management at some point, and nominally a "faster computer" in those days meant that those times I asked the computer to do something the computer would finish it's work quicker. Now it's much more about how responsive the machine will be... for a while, until it magically slows down over time again.

[0]: https://danluu.com/input-lag/

That's just so true!

The right optimizations at the right moment can have a huge boost for both the product and the company.

However the old tenet regarding premature optimization has been cargo-culted and expanded to encompass any optimization, and the higher-ups would rather have ICs churn out new features instead, shifting the cost of the bloat to the customer by insisting on more and bigger machines.

It's good for the economy, surely, but it's bad for both the users and the eventual maintainers of the piles of crap that end up getting produced.

On which OS?

Not to mention that the "human input" can be pre-scripted to urge you to purchase more, so it's not genuinely a human interaction, it's only a human delivering some bullshit "value add" marketing verbiage.

Show me what it is I said that makes you think that.

That's fine! It's probably because they're idiots and you're really smart, but it's obviously not because there's no tradeoff.

Where did I say any of this? I could teach anyone to make faster software in an hour or two, but myths like the ones you are perpetuating make people think it's difficult or faster software is more complicated.

You originally said that making software faster 'decreases velocity and sacrifices features' but you can't explain or backup any of that.

You agree with me, it turns out!

I think what actually happened is that you made some claims that get repeated but they aren't from your actual experience and you're trying to avoid giving real evidence or explanations so you keep trying to shift what you're saying to something else.

The truth is that if someone just learns to program with types and a few basic techniques they can get away from writing slow software forever and it doesn't come at any development speed, just a little learning up front that used to be considered the basics.

Next time you reply show me actual evidence of the slow software you need to write to save development time. I think the reality is that this is just not something you know a lot about, but instead of learning about it you want to pretend there is any truth to what you originally said. Show me any actual evidence or explanation instead of just making the same claims over and over.

Java and Python are not on the same body of water, let alone the same boat.

You can see some comparisons here:

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

Is one or two hours of two engineers' time more than zero hours, or no?

> just a little learning up front

Is a little learning more than zero learning, or no?

IMO your argument would hold a lot more weight if people felt like their software (as users) is slow, but many people do not. Save for a few applications, I would prefer they keep their same performance profile and improve their feature set than spend any time doing the reverse. And as you have said multiple times now: it does indeed take time!

If your original position was what it is now, which is "there's low hanging fruit," I wouldn't disagree. But what you said is there's no tradeoff. And of course now you are saying there is a tradeoff... so now we agree! Where any one person should land on that tradeoff is super project-specific, so not sure why you're being so assertive about this blanket statement lol.

This is exactly what I'm talking about. When I'm actually using my computer, its orders of magnitude faster. Things where I'd do one click and then practically have to walk away and come back to see if it worked happen in 100ms now. This is the machine being way faster and far more responsive.

Like, OK, some Apple IIe had 30ms latency on a key press compared to 50ms on a Haswell desktop with a decent refresh rate screen or 100ms on some Thinkpad from 2017, assuming these machines aren't doing anything.

But I'm not usually doing nothing when I want to press the key. I've got dozens of other things I want my computer to do. I want it listening for events on a few different chat clients. I want it to have several dozen web pages open. I want it to stream music. I want it to have several different code editors open with linters examining my code. I want it paying attention if I get new mail. I want it syncing directories from this machine to other machines and cloud storage. I want numerous background agents handling tons of different things. Any one of those tasks would cause that Apple IIe to crawl instantly and it doesn't even have the memory to render a tiny corner of my screen.

The computer is orders of magnitude "faster", in that it is doing many times as much work much faster even when it's seemingly just sitting there. Because that's what we expect from our computers these days.

Tell me how fast a button press is when you're on a video call on your Apple IIe while having a code linter run while driving a 4K panel and multiple virtual desktops. How's its Unicode support?

I'm far faster changing my WiFi network with the new quick settings menu than going Start > Control Panel > Network and Sharing Center (if using Vista or newer) > Network Devices > right click network adapter > Connect / Disconnect > go through Wizard process to set up new network. Now I just click the quick settings, click the little arrow to list WiFi networks, choose the network, click connect. Way faster.

I'm also generally far faster finding whatever setting in the Settings menu over trying to figure out which tab on which little Control Panel widget some obscure setting is, because there's a useful search box that will pull up practically any setting these days. Sure, maybe if you had every setting in Control Panel memorized you could be faster, but I'm far faster just searching for the setting I'm looking for at the moment for anything I'm not regularly changing.

The new Settings area, now that it actually has most things, is generally a far better experience unless you had everything in Control Panel committed to muscle memory. I do acknowledge though there are still a few things that aren't as good, but I imagine they'll get better. For most things most users actually mess with on a regular basis, it seems to me the Settings app is better than Control Panel. The only thing that really frustrates me with Settings now on a regular basis is only being able to have one instance of the app open at a time, a dumb limitation.

Every time I'm needing to mess with something in ancient versions of Windows these days is now a pain despite me growing up with it. So many things nested in non-obvious areas, things hidden behind tab after tab of settings and menus. Right click that, go to properties, click that, go to properties on that, click that button, go to the Options tab, click Configure, and there you go that's where you set that value. Easy! Versus typing something like the setting you want to set into the search box in Settings and have it take you right to that setting.

You made up stuff I didn't say, you won't back up your claims with any sort of evidence, you keep saying things that aren't relevant, what is the point of this?

This thread is john carmack saying the world could get by with cheaper computers if software wasn't so terrible and you are basically trying to argue with zero evidence that software needs to be terrible.

Why can't you give any evidence to back up your original claim? Why can't you show a single program fragment or give a single example?

And once again, on some Linux machines I've had over the years, doing an ip a command could hang or take a while if the device is in a bad state or being weird. It normally returns almost instantly, but sometimes has been slow to give me the information.

Not sure what this means; the eye doesn’t perceive anything. Maybe you’re thinking of saccades or round-trip response times or something else? Those are in the ~100ms range, but that’s different from whether the eye can see something.

This paper shows pictures can be recognized at 13ms, which is faster than 60hz, and that’s for full scenes, not even motion tracking or small localized changes. https://link.springer.com/article/10.3758/s13414-013-0605-z

It's obviously true the world could get by with cheaper computers if software was more performant.

So why don't we?

We know that it isn't difficult because if it was you would have had a single shred of evidence after a dozen comments of me asking for it.

Secure string functions are built into C these days. The older error prone ones are as well. You can ban the older functions from code bases, but it is hard to justify outright bans for all of them. If you audit string function usage in a non-trivial codebase, you likely will find instances where the old, error prone, string functions are used in safe ways and leaving them alone makes sense. This is particularly the case when constant length strings are used with constant length buffers. Here is an example where the old string functions are just as safe as the secure string functions:

https://github.com/openzfs/zfs/blob/master/etc/systemd/syste...

I found it when I audited the string function usage in OpenZFS with the goal of removing all uses of the older string functions. While I replaced every instance old string function where the secure string functions mitigated even the slightest risk, I could not bring myself to remove these, since there was nothing wrong with them. After my patches, a few string functions were then banned from the codebase with a build system hack put in place to break the build process if someone tried to reintroduce the banned functions.

https://github.com/openzfs/zfs/commit/303678350a7253c7bee9d6...

You could argue otherwise and you would not be wrong since the codebase had not given this code inputs that would overrun the buffer. However, any case where you loop until the string is built needs a check on each iteration unless you can both prove that the buffer will always be long enough for any possible output and guarantee that future changes will preserve this property. The former is a pain (but doable) while the latter was infeasible, which is why the bounds checks were added.

That said, something as innocuous as printing a floating value could print 308 characters where you only expected 10 or less:

https://github.com/openzfs/zfs/commit/f954ea26a615cecc8573bb...

Edge cases causing things to print beyond what was expected are a good reason why people should use bounds checks when building strings, since truncation is fail safe, while overrunning the buffer is fail dangerous. I am a fan of the silent truncation done in both patches, since in both cases, truncation is harmless. For cases where silent truncation is not harmless, you can use detect the truncation by checking the return value of `snprintf()` and react accordingly. It should be said that the scnprintf() function's return value does not permit truncation detection and `snprintf()` should be used if you want that.

Note that I am the author of those two patches, so it is natural that I like the approach I used. They were written as part of an audit of the OpenZFS codebase I did when bug hunting for fun.

Security through compartmentalization approach actually works. Compare the number of CVEs of your favorite OS with those for Qubes OS: https://www.qubes-os.org/security/qsb/

People wonder why I don't run Windows outside of gaming and it because I don't really know what the system is doing anymore.

It has been sacrificed in the name of developer productivity, since hardware is cheap compared to the cost of writing efficient software outside of performance critical situations. The result is that the world is drowning in inefficient software.

Because Python is an interpreted language and Java has garbage collection, not because they have bounds checking.

Using a language like Rust the bounds checking overhead compared to C code is usually minimal, like 0-5%. The compiler can even optimize away many bounds checks (safely) if you structure your code properly, such as with iterators.

Here's an example article : https://shnatsel.medium.com/how-to-avoid-bounds-checks-in-ru...

Make sure you read the note about how the author was mistaken about the 15% speedup from bounds checking. The actual bounds check change was much less, like a couple percent. You can even structure your code so that the bounds check disappears altogether when the compiler can confirm safety at compile time.

Bounds checking barely registers as a factor.

The comment I quoted was about 20 second load times, not a slight delay before something is clickable. That's the exaggeration.

FWIW, I don't see the same slowness in Signal, like the other poster.

And furthermore I don’t suspect you’re proposing we should be using C + bounds checking (that’s already a Gcc flag?). But rather bounds checking is one of many safety features.

The whole pitch of Java is exactly what OP said - let’s just pay 10-30% cost to get these nice portability and memory benefits over C++, and it didn’t work that way especially as memory speeds have diverged from CPU.

tl;dr: Qubes security relies on Xen, which is quite popular. But even Xen has more vulnerabilities than Qubes thanks to a clever design: https://www.qubes-os.org/security/xsa/#statistics.

Should I draw from this conclusion that modern software is not designed to run on modern hardware?

Nintendo can do it because they only have one hardware target (unlike multiplatform games) and they can spend an extra year or two doing performance work.

No, actually, C++ is pretty much as low as you can go.

Well, I mean, you can go lower but you're not going to get performance benefits. You could go down to C. But C is going to be more of the same or, more likely, slower. You're going to be swapping Templates for things like void *.

You could go to assembly, but let's be honest - who can write better assembly than a C++ compiler?

The stuff that used to be slow involved hard drive access, but today even when programs don't need to touch the disk they often manage to rack up significant delays. Not to mention how SSDs have 100x less latency than hard drives.

And if unicode support is causing serious delays when I'm only using one block of simple-rendering characters, then the library was designed badly.

In other words, yes you can eek out more performance at lower levels. Then again at the silicon level. No, it's not worth it in 99.9999% of scenarios (because there are tradeoffs).

Movies’ 24Hz is too slow, just watch a horizontal pan. 24Hz is good enough for slow things, but it was chosen that low for cost reasons, not because it’s the limit of perception. US TV’s 60hz interlace isn’t the limit either, which is also shown with horizontal pans. 60hz progressive looks different than 30hz, just watch YouTube or turn on frame interpolation on a modern TV.

The limit of meaningful motion tracking perception might be in the 100-200Hz range. The reason 500Hz is meaningful to gamers is, I think, because of latency rather than frequency. Video systems often have multiple frames of latency, so there actually is a perceptible difference to them between 60Hz and 500Hz.

I don’t know what typical display latency of just browsing files with a monitor these days. I’d guess it’s probably a few frames, and I’d bet we would be able to feel the difference between 3 frames of latency at 144hz and 1 frame of latency at 144hz. I’m also curious if mouse cursor motion blur would make any difference.