Hacker News Reader

Comment by AnimalMuppet | Hacker News Reader

It happened one step at a time.

We wanted multi-tasking OSes, so that we could start one program without having to exit the previous one first. That made the OS a lot bigger.

Eventually, we got web browsers. Then Netscape added caching, and browsers got faster and less frustrating, but also bigger. And then they added multiple tabs, and that was more convenient, but it took more memory.

And they kept adding media types... and unicode support... and...

We used to write code in text editors. Well, a good IDE takes a lot more space, but it's easier to use.

In short: We kept finding things that the computer could do for us, so that we wouldn't have to do them ourselves, or do it more conveniently, or do something at all that we couldn't do before. The price of that was that we're dragging around the code to do all those things. By now, it's a rather large amount to drag around...

View on HN

This is all very true, but I feel like we (as users) haven't really gained proportionally compared to the increase in computing power and storage.

For example IDEs: Visual Studio in 2017 is certainly better than Visual Studio in 1997, but do those advancements really justify the exponential growth in hardware requirements?

How'd we get so little usable functionality increase for such a massive increase in size/complexity?

Would you get twice as much from your car if you install 2x more powerful engine? Would a 2x more powerful weapon win you 2x more wars? Would 2x better medicine technologies allow you to live 2x longer?

Exactly that : diminishing returns are everywhere.

My exact thoughts. What the heck is VS doing? No IDE should require the amount of resources it does to where it is almost unusable on any computer > 5 years old (assuming said computer wasn't overpowered to start with).

Yes, they do. Computers are cheap; humans are expensive. In an average application (including IDEs), most CPU time is spent idling waiting for user input. Most memory is idle unless you have something like superfetch caching stuff ahead of time for you. If the new features make users faster, they're decidedly worth it.

Fundamentally, modern systems are much more usable - in every sense of the word. Modern IDEs are more accessible to screen readers, more localizable to foreign languages including things like right-to-left languages, do more automatic syntax highlighting, error checking, test running, and other things that save developer cycles, and on and on. Each of these makes the program considerably more efficient.

Personally I get grumpy when modern IDEs make me wait on them. I don't care that much about CPU/RAM usage until the computer starts wasting my time while I'm trying to work. That's sadly very common these days even on relatively beefy hardware.

So I agree with you that computer time is cheap and user time is not, but I think we could optimise better for user time.

> Fundamentally, modern systems are much more usable...

I just don't buy this premise. _Some_ systems are more usable. But take a look at Microsoft Excel from circa 1995-2000, which came with a big thick textbook of documentation, explaining what every single menu item did. Every single menu item was written in natural language and it told you what it would do. Professionals used (and still use) Excel, crafting workflows around the organization of the UI. It's a tool that is used by actual people to accomplish actual tasks.

Now look at Google Sheets. It has about 1/10th the functionality of Microsoft Excel (hell--it can't even do proper scatter plots with multiple data series) and its UI is an undiscoverable piece of crap because half of it is in _iconese_--a strange language of symbols that are not standardized across applications, confusing and ironically archaic depictions of telephones, arrows, sheets of paper, floppy disks. The program is written in a pictographic language that must be deciphered before being used. Software doesn't even speak our natural languages anymore...we have to learn _their_ language first...and every application has its own and that language changes every six months. Worse, all those funky pictograms are buttons that perform irrevocable actions. They don't even explain what they did or how to undo it...it makes users less likely to explore by experimentation.

...and there is no manual, there is no documentation. It will be all different in six months, with less functionality and bigger--different!--icons...takes more memory.

We are regressing.

Hey but those animations are spiffy.

/rant

Google Sheets can be shared via a URL and anyone with a web browser can access it instantly. No need for Windows, no need for an Excel license, no need for a desktop computer. You cancollaborate in real-time too.

So you can share and collaborate...but the functionality to actually _create_, that's hopelessly oversimplified and undocumented. I think you are missing my fundamental point.

My point is that for many, the creation functionality is not bad enough to offset the availability and collaboration benefits.

I see this as a disappointing race to the bottom for the quality of artifacts that we produce and the tools with which we produce them.

> For example IDEs: Visual Studio in 2017 is certainly better than Visual Studio in 1997

Is it? 97 might be a bit extreme, but the other day I opened an old project which was still on VS2010 and I was struck by how much faster 2010 was while still having nearly every VS feature that I wanted. They're slowing porting VS to .net and paying a huge performance penalty for that.

That's the type of example I've come across all too frequently. Software that's 5-10 years old, has all the same functionality, uses a fraction of the resources, and is often "better" in several ways.

Older versions of Android Facebook seem massively faster and use a fraction of the RAM while providing (nearly?) the same functions and features.

Excel 2000 is lightning quick compared to the modern versions (well, 2013 is as modern as I got)

And VS2010 is itself _much_ slower than previous versions.

Try VS 2008 for speed. And it had distinguishable icons!

I think this is the tragedy of the commons. Computers are getting better. Each team says in its heart "We can be a bit wasteful while providing feature X." When aggregated the whole thing is slower.

I think your comment is closest to reality. I believe it was incremental and deliberate, but the key piece that is missing from your assessment is that we (the royal "we") haven't given a lot of attention to correcting any poor choices. I think you are right when you say that hardware improvements helped encourage devs to give more tasks to the machine like encoding, caching, etc. However, it also became less important to revisit the underlying pieces on top of which we added these new features. It eventually became this dirty snowball rolling downhill that was built from layers of whatever was in the way as well as anything we could throw at it.

For example, the web might be filled with redundant and bloated software, but the real problem is that the browser has become the nexus of virtualization, isolation, security, etc. for almost everyone from the causal user to hardcore admins and for every piece of software from frameworks/utilities to full-blown SAPs. It's like we have all reached a common understanding for what comprises a "good" application, but then we lazily decided to just implement these things inside another app. I mean, webassembly is great an all, but is it wise?

I don't think it's about IPC or RAM or (n+1) framework layers that each include "efficient list functions". I think it about the incremental, deliberate, and fallacy-laden decisions that assign more value to "new" than to "improved".

Reply on news.ycombinator.com