Slashdot Mirror
'It Just Seems That Nobody is Interested in Building Quality, Fast, Efficient, Lasting, Foundational Stuff Anymore' (tonsky.me)
Nikita Prokopov, a software programmer and author of Fira Code, a popular programming font, AnyBar, a universal status indicator, and some open-source Clojure libraries, writes: Remember times when an OS, apps and all your data fit on a floppy? Your desktop todo app is probably written in Electron and thus has userland driver for Xbox 360 controller in it, can render 3d graphics and play audio and take photos with your web camera. A simple text chat is notorious for its load speed and memory consumption. Yes, you really have to count Slack in as a resource-heavy application. I mean, chatroom and barebones text editor, those are supposed to be two of the less demanding apps in the whole world. Welcome to 2018.
At least it works, you might say. Well, bigger doesn't imply better. Bigger means someone has lost control. Bigger means we don't know what's going on. Bigger means complexity tax, performance tax, reliability tax. This is not the norm and should not become the norm. Overweight apps should mean a red flag. They should mean run away scared. 16Gb Android phone was perfectly fine 3 years ago. Today with Android 8.1 it's barely usable because each app has become at least twice as big for no apparent reason. There are no additional functions. They are not faster or more optimized. They don't look different. They just...grow?
iPhone 4s was released with iOS 5, but can barely run iOS 9. And it's not because iOS 9 is that much superior -- it's basically the same. But their new hardware is faster, so they made software slower. Don't worry -- you got exciting new capabilities like...running the same apps with the same speed! I dunno. [...] Nobody understands anything at this point. Neither they want to. We just throw barely baked shit out there, hope for the best and call it "startup wisdom." Web pages ask you to refresh if anything goes wrong. Who has time to figure out what happened? Any web app produces a constant stream of "random" JS errors in the wild, even on compatible browsers.
[...] It just seems that nobody is interested in building quality, fast, efficient, lasting, foundational stuff anymore. Even when efficient solutions have been known for ages, we still struggle with the same problems: package management, build systems, compilers, language design, IDEs. Build systems are inherently unreliable and periodically require full clean, even though all info for invalidation is there. Nothing stops us from making build process reliable, predictable and 100% reproducible. Just nobody thinks it's important. NPM has stayed in "sometimes works" state for years.
At least it works, you might say. Well, bigger doesn't imply better. Bigger means someone has lost control. Bigger means we don't know what's going on. Bigger means complexity tax, performance tax, reliability tax. This is not the norm and should not become the norm. Overweight apps should mean a red flag. They should mean run away scared. 16Gb Android phone was perfectly fine 3 years ago. Today with Android 8.1 it's barely usable because each app has become at least twice as big for no apparent reason. There are no additional functions. They are not faster or more optimized. They don't look different. They just...grow?
iPhone 4s was released with iOS 5, but can barely run iOS 9. And it's not because iOS 9 is that much superior -- it's basically the same. But their new hardware is faster, so they made software slower. Don't worry -- you got exciting new capabilities like...running the same apps with the same speed! I dunno. [...] Nobody understands anything at this point. Neither they want to. We just throw barely baked shit out there, hope for the best and call it "startup wisdom." Web pages ask you to refresh if anything goes wrong. Who has time to figure out what happened? Any web app produces a constant stream of "random" JS errors in the wild, even on compatible browsers.
[...] It just seems that nobody is interested in building quality, fast, efficient, lasting, foundational stuff anymore. Even when efficient solutions have been known for ages, we still struggle with the same problems: package management, build systems, compilers, language design, IDEs. Build systems are inherently unreliable and periodically require full clean, even though all info for invalidation is there. Nothing stops us from making build process reliable, predictable and 100% reproducible. Just nobody thinks it's important. NPM has stayed in "sometimes works" state for years.
We've been trained to be a consuming society of disposable goods. The latest and greatest feature will always be more important than something that is reliable and durable for the long haul.
Nobody has a clue anymore whether they're building on a poured concrete foundation or a bag of cats.
At least for now. Comsumer laptops have been suck on 8GB since 2011 when Sandy Bridge came out.
When the speed of your processor doubles every two year along with a concurrent doubling of RAM and disk space, then you can get away with bloatware.
Since Moore's law appears to have stalled since at least five years ago, it will be interesting to see if we start to see algorithm research or code optimization techniques coming to the fore again.
Perpetual growth also means selling more than last time, and the only way to do that is to make people want your new stuff. This is possible only in two ways: First, your new stuff is so much better than the old one that people WANT it, or second, the old one is already broken so people have to buy it.
Since inventing new stuff that people want badly enough to drop another wad of dough for it even though the old one's still working is hard but making stuff that breaks easily is easy...
We used to have a Bill of Rights. Now, with the rights gone, all we have left is the bill.
Every now and then Apple does take a step back and work towards making things smaller and faster instead of just newer.
iOS 12 spent a lot of time on just that, especially on making sure the latest software was actually making the oldest devices faster, Reports were the execs were all carrying around iPhone 6 and 6s units for the last few weeks making sure they felt usable.
Similarly OSX has improved in the same way this year, being faster on older hardware - finding my 2010 MacBook Pro still well supported.
I think as developers one thing we can all do to help reverse this trend is to simply be very, very careful about inclusion of third party libraries. That's where a lot of the bloat comes in, you add a few libraries and maybe it has a few dependencies and after a short time you are building in 20-30 subprojetts. Madness.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Unix solved most of the problems associated with an operating system. It's just that most folks don't take the time to learn their history or look at existing solutions. Instead NIH and "I can do it better" syndrome are the rule. I see this constantly on /. and elsewhere. Folks acting like very old technology is brand new, or acting like something that was invented yesterday isn't a blatant copy of previous tech. Even Window is still trying to catch up to technology that's been in various Unix variants for 20+ years. Unix is the way and the light. Specifically, I think the BSD's have the right mindset. As a nice bonus, the non-graphical installation runs off all the Ubuntites. Yay!
Not only do we write document scan and OCR software (ExactScan, OCRKit, Recompres, etc.) that fits on a couple of floppies (well ExactScan non Pro would fit on two 1.44MB I guess), without hundreds of imported dependecies and such: https://exactcode.com/ – On my new youtube channel I recently showed how to program hardware accelerated 3d in a couple of hundred lines of code! Enjoy: https://www.youtube.com/watch?...
Support your state's Right to Repair bill! Part of the reason "everything sucks now" is that we let these fuckers sell us crap that only they can fix.
while yes there is a point that bigger doesn't imply better
however the example about the iPhone 4s is completely wrong... iOS 5 had a long list of things that where wrong with it compared to iOS 9 for example the browser was not anywhere near as good as iOS 9 and comparing sizes on Android 8.1 is not really a very good metric just look at the media assets that are combined in the binary.
But that would take a understanding of actually how things work... not writing a snazzy headline...
the fact that you cant come up with a simple example show's its not quite that simple
I assert that Agile is antithetical for this kind of work. It's critical that infrastructure be built to completion (in both functionality and quality). A lot of infrastructure doesn't lend itself to "requirements on 3x5 cards" For example, how would you handle "consistent concurrent updates" in a distributed system? That's an architectural/key design issue that has substantial repercussions throughout a distributed system.
I've worked on several projects producing on reliable software infrastructure. One was all new code, most others included a lot of COTS. Each had a substantial effort to capture 'architecture' and 'requirements,' including establishing what "100%" looked like so we could track progress to completion, and so the users/customers of of the infrastructure had an idea what features and capabilities they could depend on.
DevOps might work, -if- there's a substantial investment in up front architecture, design, and build planning.
(My sense of "architecture" here includes non-functional considerations, deployment issues, and even identifying human contributions to the system, i.e. how the infrastructure will be configured and maintained.)
Letter Perfect for the Atari 800 was an 8K ROM cartridge.
Image: http://www.atarimania.com/utility-atari-400-800-xl-xe-letter-perfect_13691.html
Documentation (100 page PDF): http://www.atarimania.com/8bit/files/letter_perfect.pdf
Remember times when an OS, apps and all your data fit on a floppy?
Sure do. I also remember that it did close to fuck all in the way of useful tasks compared to the devices I have right now. Is there a point to this nostalgia over what now is primitive technology? If your OS fits on a single disk it is either a VERY narrowly focused device that doesn't do much else or it is a very primitive system that cannot do much. Just because something isn't coded in hand written assembler doesn't mean it is bad.
iPhone 4s was released with iOS 5, but can barely run iOS 9. And it's not because iOS 9 is that much superior -- it's basically the same. But their new hardware is faster, so they made software slower.
No they made it DO MORE. It didn't get slower out of incompetence or laziness. (well mostly anyway...) It is a more complicated system that does tasks that weren't previously possible with the older hardware. It's NOT "basically the same" if you really look at it carefully. A lot of new technology has been added which comes at a cost. You could run the old system on the new hardware and it would run faster but do fewer useful things. Pick your poison. I remember running the same DOS system that ran on my 286 on a 486 and it was a whole lot faster but it didn't really take full advantage of that extra speed for most tasks. The code was written the way it was because of the hardware limitations of the day. No different than today.
It just seems that nobody is interested in building quality, fast, efficient, lasting, foundational stuff anymore.
This statement presumes A) that software in the past was all those things (it wasn't) and that B) that the meaning of all those things is clear (it isn't). Define "quality". Define "fast". Define "efficient". And under what context are we talking? That statement makes for a good sound bite but it's as vague as an astrology reading if you really think about it.
The problem is that in the past the growth used to apply to both the company and the consumer: the company sold new gadgets and so grew and the gadgets had new functionality which meant that their usefulness to the consumer grew. Now though it seems that there is very little growth in capability particularly from Apple. New iPhones have faster processors, nicer screens and better cameras but no really new functionality: they are just epsilon better than the previous model with fancier fonts and animations.
A compiler and editor in 64K, and the whole environment was lightning fast on a 8088 machine with floppy disks for storage. I very much agree with the OP - things in IT in general have gotten bigger, fatter, and less predictable. This is not progress.
Yes, I am old enough to remember the floppy disk days - when wanting to play Doom, with its billboarded sprites and single-floor rooms, meant loading 18 zillion floppies into your drive. When wanting to draw a freakin' Mandelbrot set meant waiting 3 minutes, and god help you if you wanted to dabble in 3D graphics - I guess you could look up quaternions in the encyclopedia and try to go from there?
Doesn't anyone hear themselves making the "back in the good old days" argument? I hear it again and again, and no one ever seems to notice themselves re-hashing the same tired old pining for a glorious past that never was, or lamenting how terrible "kids today" don't care about quality and want to destroy society.
Things are *good* today. Not perfect, but that's natural in software. The programs of old (that we still use) have fewer bugs because they had like 1% of the code of modern projects, and have now had 40 years of experts staring at them. Of course they'll be less buggy than anything ambitious and new.
If you don't like it, get your hands on the keyboard and build something better. That's what engineers do.
Back in the DOS days, there was a word processor battle between Word Perfect and Microsoft Word.
The developers behind Word Perfect wanted a small size app that was fast -- it was mostly programmed in assembler.
Meanwhile, Microsoft was programming theirs in C and cranking out the updates and features at the expense of size and speed.
Who won? Microsoft. Why? Because hardware continues to get faster and faster every year. Optimization becomes less necessary.
That trend continues today, but there's another reason for this: The 80/20 rule. Programmers want to program sexy easy stuff -- the 80 part. They don't want to hunt down bugs and optimize -- the 20 part. Companies don't want to pay for the 20 part either.
The customer has no choice in the matter. The people that make the decisions and hire/fire are the ones that do. Lets take a look at a typical DevOps or NoOps shop:
1: The devs are mainly junior to intermediate level. Senior devs get the axe because they cost too much.
2: What matters is getting deliverables that marketing has already sold to a customer.
3: The devs are asked each day about said deliverables in the Scrum stand-up meeting.
4: If the devs don't cough that deliverable up -yesterday-, they get replaced by someone else who can.
In this environment, technological debt is someone else's problem. All that matters is getting stuff working and the code artifacts into production. Security, or readability? That's other people's problems.
This is the modern company. The days of people writing code in assembly to get everything to work perfectly and still have room on a floppy disk are over.
Blame the bad top brass, who short their stock before a security breach is announced so they can swing a new yacht, and who can't hear anything over their own ego. That is where the fault resides.
If they built it that way, they couldn't keep making money on it.
The millennial that doesn't like most of the stuff designed for millennials.
We're now several abstraction layers deep for the most mundane of programs.
Only the State obtains its revenue by coercion. - Murray Rothbard
Is another man's critical feature. I thought I'd say that here since you wouldn't get the message in animated poo form on your iOS 5 device.
Comparing the floppy based apps to what we get now is absolutely daft. Especially daft considering that modern office loads faster now than anything on floppy ever did, and there's a big difference in capability between apps.
You want a text editor, can I recommend nano or notepad.exe. Personally I prefer something more capable, compatible, and something that I can drive from my couch using an xbox controller.
Actually back in those days people did a lot of typing for a living preferred WordPerfect over Word. WP had some nice features like "show codes" if your formatting was fubar you could see what was causing it.
Only the State obtains its revenue by coercion. - Murray Rothbard
It may be the hardest thing the human mind has ever done
What we need are clever, powerful, rigorously proven correct tools to manage complexity and improve quality
What we have instead is layer after layer of bloated, buggy, inefficient crap, designed to allow inexperienced, inexpensive, barely competent worker bees to rapidly churn out vast quantities of bloated, buggy, inefficient crap to serve the fashion industry
Some apps (and not that many) have added code to increase security. This is honestly a good thing. Also, like most good things, this is not the majority of apps.
On the flip side, they have absolutely added functionality - for the developers: Data collection, as much as they think they can even remotely talk you into. This is a problem.
We don't perceive this as a feature, but they do. That additional code is definitely serving their purposes.
Yes, and I also remember that the machine wasn't very useful beyond for playing Alley Cat and Leisure Suit Larry.
Yeah, yeah, javascript is slower than C, complex software is hard to optimize, etc... all true, but he entirely fails to recognize the gains that have been made in software as a consequence of accepting these faults. On IOS 5 vs 9, what about the encryption and other security features that have been extensively discussed here on /., just to start? On web apps, I resisted moving away from mutt as an email client for years, but I'm now a dedicated webmail user because I can get the same interface on multiple machines without any hassle, despite the fact that all that javascript is much more taxing on machines. Same's true for my feed reader, book library, budgeting software, and various other tools.
NPM may be a pile of cruft, I don't know. Google Maps on Android is heading in that direction, I'll agree. There are definitely some bad actors, but that doesn't mean that everything using more than 640 kb is bloat.
The generality that "There are no additional functions [programs] just... grow?" is rose-tinted bullshit.
So... what do we do about it?
As consumers, we can drive the market by confining our purchases to less bloat or no bloat. But how do we do that? If not IOS or Android, then what? I'm already running Mint on my laptop at home -- but I still need to run that bloated monstrosity called Windows for the single horribly bloated application that doesn't work correctly under Wine.
A few years ago I got a freebie Android tablet with a big purchase that was obsolete basically out of the box. Yes, it supported SD cards, but you couldn't put apps on the card. Just installing the Facebook app on top of the preinstalled bloat was enough to get "out of memory" errors. It's now sitting in a drawer.
Oliver's law of assumed responsibility: If you're seen fixing it, you will be blamed for breaking it.
There's probably some truth to that. And it's a sad commentary on the industry.
Oliver's law of assumed responsibility: If you're seen fixing it, you will be blamed for breaking it.
I used to be with 'it', but then they changed what 'it' was. Now what I'm with isn't 'it' anymore and what's 'it' seems weird and scary. It'll happen to you!
also:
The children now love luxury. They have bad manners, contempt for authority; they show disrespect for elders and love chatter in place of exercise.[1]
the preceding comment is my own and in no way reflects the opinion of the Joint Chiefs of Staff
But we might be reaching an inflection point (for many reasons like accumulation of negative consequences or hardware not improving so much so quickly anymore) where things done badly will stop being compensated by advantageous conditions and problems will start showing up (e.g., slow performance on powerful computers). These last years might have been the spoiled, ignorant stage of software development. The most logical long-term evolution seems those short-term-concerned attitudes to disappear. Doing things properly, knowledgeably and by eminently focusing on the long term will always succeed in the long run.
Custom Solvers 2.0 = Alvaro Carballo Garcia = varocarbas.
You're revising history. Microsoft won because they f--ked WordPerfect over, withholding technical details about Win95.
The basic tenets of capitalism are for the company to make the most money possible and for the consumer to pay the least as possible. There is no reward for working harder towards any ethical or moral goal. You cannot escape from this without changing the system.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
The trade-offs will obviously vary from one task to another, but it seems to me that the trade-offs with the most obvious root justification are also the ones which have the most impact on this discussion. For instance: Prokopov's comment about apps being at least twice as big can very frequently be explained by toggling the IDE's compiler from 32-bit to 64-bit. So no: there are absolutely no user perceivable benefits from that change -- you know, aside for the simple fact that 32-bit apps are being phased out entirely.
Another obvious justification -- though, perhaps a slightly more contentions one -- is the notion of optimizing for developer productivity, instead of for coding efficiency. I used to take great pride in providing a more elegant and clean coded solution than those of my peers, but anymore I find myself leaning more heavily on "frameworks" and "libraries", in spite of the fact that I know full well that each and every one I use is going to add more bloat to my app. So why do I use them? Duh... so that I don't have to rebuild the wheel. Someone else built that wheel -- in many cases, several someone else's -- and I have no desire whatsoever to spend the next 40 to 80 work hours muddling through all of the different use case scenarios, when someone else has already done all of that work for me and several other people have debugged and refined it, on top of that.
So do I care about efficient code? Sure. But I care about my own efficiency, quite a bit more.
Whenever I see an article like this it reminds me of what Aldus did decades ago. (Quick history...Aldus PageMaker was bought by Adobe which later changed the name to InDesign.)
One release of the program was something like seven 1.4 Mb disks. At that time this was a lot. Not to fall back on their laurels, they rewrote the program from scratch. Their next version contained a lot of the most wanted features people had been asking for...and took only four disks.
This was the first and only time I ever saw reviewers concentrate on optimized coding rather than the user experience.
Care killed the cat, but satisfaction brought it back.
I really think a lot of it is crap.
He starts with a premise that "Modern cars work, let’s say for the sake of argument, at 98% of what’s physically possible with the current engine design." and then goes on to lament why software, computers, hardware etc is not at the same 98% level.
But let's be serious - the infrastructure (roads, lights, bridges, signage, "power supply") is not changing on a daily basis. "Current engine design" is mostly based on a decades-old model, and new thinkers and fresh ideas face a mountain of resistance trying to get new concepts launched.
The car manufactures, parts manufactures, labor unions, distribution channels, sales dealerships, govt agencies, international agreements, etc. all have a vested interest in preventing disruption from being introduced let alone getting a foothold. They also have deep enough pockets to either buy&bury ideas or wrap up in expensive litigation and also launch an all-out media blitz to spread FUD.
So sure, if all we had was the old IE as our one and only browser, things would be different. M$ could push its weight around and prevent new browsers from taking hold. Software developers could write all code for IE. We'd use silverlight and ADP and IIS and our stuff would work 98% of the time and what, the world would be better off with all of that stagnation?
That's not the only problem I have with his article, it is just the first of many. Every "issue" he points to, taken by itself and viewed only from his perspective, would seem to have merit. But if you do any further review and apply some critical thinking, his house of cards comes crashing down.
Take the NPM graph. Yes there are a lot of modules from various different sources, all woven together into a working app. Yes there is fragility in that a single update to one of the modules can disrupt the whole. So this is true, but what is the solution? Would NPM be better if the developers coded everything themselves by hand? Is the world really going to be better if every project is 100% home grown so as to not have the same sort of dependency graph?
Or his Docker rant: "we put Docker inside virtual machines, simply because nobody was able to clean up the mess that most programs, languages and their environment produce." Docker isn't popular because of the cruft in programs, languages and environments. While it is true that each Linux distribution has its own take on system layout and admins can further customize, Docker isn't there to cover a mess. Docker provides application isolation from the underlying host, but it also provides host isolation from the applications. Containerization and isolation are good things because of the preventative aspects they provide, not because they are trying to hide messes.
A piece of software is nothing more than a collection of choices. Each choice is typically made individually, and the hope is that making the right individual choices will lead to a solution which represents the best possible outcome. I can choose whether to use commons-lang for a string utility or I can write my own, each side has pros and cons and I will choose the best path based on how the code will be used. If I'm building a generic war, I'm not going to make the same decision that I would if I were targeting an embedded JVM on a piece of hardware. It is easy on the outside to later claim my war is bloated or my embedded solution is lacking some additional useful methods, but those complaints are based upon not appreciating the various choices that were made for the right reasons.
This guy's at odds with himself. If he wants a fast starting mobile phone, there are still carriers that provide flip phones w/ limited app support, features and functionality. They start up really fast, so he should be happy. But he wouldn't be, he'd be lamenting the fact that his phone doesn't have what the others have.
The Kuhn Rikon Swiss Peeler. Go into any high-end restaurant kitchen, and there's a good chance you'll find a couple of these marvels. You, the home cook, can own this wonder too, but it will set you back: $4.49.
Now go into a home kitchen supply store and you'll find peeling gizmos costing four or five times as much that don't work as well. Somebody once gave me a Wustof peeler that costs over $50, and you know what? It's just as good as the Rikon at over 10x the price. It's pretty to look at, and nicer to hold, but it doesn't get your spuds naked any faster.
So why do people shell out $20,$30, even $50 for a vegetable peeler if the best peeler in the world? Because of what I call the "SUV theory of marketing": people equate heavyweight with quality, not design, performance or durability.
Office automation software hit Rikon Swiss levels of quality twenty years ago. It's possible that iOS hit Rikon Swiss levels of quality around five years ago, with support for the A7 secure enclave. After you get to a certain point, the only way to add to perceived quality is to do stuff that adds weight. Looking at iOS releases, it's probably fair to say that there have been some genuine functional improvements since iOS 7, in areas like multitasking and battery life. A lot of changes are superficial stylistic ones that dont' really matter. In some ways the operating system has found new ways to be intrusive on your attention. Those superficial changes are all excess weight added to create the perception of quality.
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
You can't worry about how long it will last or how well it works. You have to worry about what crap your selling next year. If you make it last five years thats five years worth of profits you have lost.
Once again, Companies trusting code monkeys without at least a college degree. I wouldn't trust a construction worker to design and build my house, why trust a "construction worker" software monkey then? Lots of you here...
Tired of my customary (Score:1)
How does a random programmer create these Quality, Fast, Efficient, Lasting, Foundational stuff?
For example, if one notices or feels a lack of free PDF editors, what does said programmer need in order to create one? Given the nature of this application, it's likely to be the first time said programmer wrote it, and is unlikely to be meet any of the first two. As an editor, it's going to be more complex than a viewer, and part of the complexity is from rendering the content.
Oh, and it's expected to be portable to eventually run on both Windows and Linux. Have fun.
The headline can be rephrased as "it seems that nobody is interested in building expensive stuff".
Doing things better costs money, and in that case, their customers are not ready to pay for it. Consumers pay for what they see: features, a nice GUI, etc... they don't look under the hood as long as it runs. So developers spend money on features and nice design, and do the minimum to make sure it runs well enough for most people. They get better return on investment like this.
Fast, cheap (efficient) and reliable (robust, long lasting): pick 2.
I was struck the same way by that statement, and the fact that the execs were carrying around an iPhone 6s shows real proof that they mean it. Having updates that actually make an older device nicer instead of bog down is a huge part of realizing the goal of having people use devices longer.
This is also the reason they moved the Apple Watch over to 64 bit now even though it might seem silly, this forward thinking is what has allowed Apple to provide compatible updates for all iOS devices back to the 5s, and also fairly old laptops too.
I think it's a pretty awesome goal not to need new mining. If you think about it in theory they could eventually reach a steady state where people turning in older more massive devices provide enough materials to make even more new ones (along I'm sure with some other random recycled mineral sources).
"There is more worth loving than we have strength to love." - Brian Jay Stanley
As a consulting software developer, I would (very gently and not in these exact words) tell clients they could have it good, fast, or cheap, pick two. Invariably they would insist on all three, a logical impossibility. Once we got down to it, though, it was always "good" that turned out to be where they would accept the biggest hits. Just like in the movie, The Martian, the first place they would cut corners was in testing (followed rapidly by training). Business people would tell me about how getting the contract depended on us being willing to be "result oriented" which in their minds meant pretty much skipping analysis, requirements, and design. That doesn't just sound stupid, it is stupid, although they tried hard to make it sound reasonable. In my experience most people paying for software don't even understand the first thing about how it is created. Neither do a lot of people creating it. After a few highly successful projects that boosted my rep, I only ever got assigned to ones that were on fire, late, and generally had gotten a few previous project managers fired. In none of those was I ever able to find anything to convince me they hadn't pretty much skipped the requirements phase altogether and just gone straight to coding (no one could ever produce even the most basic list of initial requirements). Another problem is the ephemeral nature of most software. Let's face it, software is here today and gone tomorrow for most things (a very few highly revered games might be the exception). My grandfather was an architect and builder. When I was little he would take me around and proudly show me neighborhoods full of high quality expensive homes he had designed and built when he was a young man, as well as office buildings and even a church. I'll never take my grandkids out on the internet and various corporate intranets and show them some of my great coding projects. Even if that was possible, most of them are already gone and my grandkids haven't even been born yet.
at least in America. It's not just because they're short sighted, see here or read up some more via google
This is also why 99 cent stores are a harbinger of doom for an economy. They make most of their money selling essentials (toothpaste, soap, toilet paper, etc) in reduced sizes at very high markups to poor people who only have a few dollars left after paying their bills. Me? I buy that stuff at a warehouse store and it saves me about $100 bucks a year vs a grocery store and closer to $300 vs a 99 cent store.
Hi! I make Firefox Plug-ins. Check 'em out @ https://addons.mozilla.org/en-US/firefox/addon/youtube-mp3-podcaster/
You don't recall the QNX demo floppy? It fit a multitasking networked OS that even included a Doom demo.
I remember a lot of things. I remember PDP-11 computers that ran the operations of entire companies with 512K of RAM. They also were the size of refrigerators, took a ton of power, and by today's standards were slower than frozen molasses. Yes you can do some impressive things in small amounts of memory if you need to. Doesn't mean it's the most efficient or effective or best or cheapest way to do it when it isn't a constraint. Do you really think the vaunted Apollo guidance computer was made the way it was just because the engineers like compact code? No it was built that way because it HAD to be.
Shit today is just bloated.
The first computer I had had a whopping 16Kilobytes of RAM. It was functional but slow and had a lot of limits. Do you really think we should be writing code the same way we did then just because we can? Do you restrict yourself to driving a Model T Ford because cars today "are just too bloated"? Do you live in a tent because houses are "just too bloated"? No you don't. There is overhead that comes with the progression of technology and that's not inherently a bad thing. Minimalism is only a virtue when it serves a functional purpose.
I understand the appeal of compact tight code. I really do. But the amount of hand wringing people make over it is just ridiculous. It's making perfect the enemy of good.
https://www.youtube.com/watch?v=G0Wltu5hfPU
"When I was a kid, it seemed like they made something new every day. Some, gadget or idea, like every day was Christmas. But six billion people, just imagine that. And every last one of them trying to have it all."
-Donald
Interstellar (2014).
The libraries grow, and libraries are statically linked. Further, languages with dynamic loading features cannot be analyzed at link time to include only what is needed, so everything must be included.
Back when people wrote in C, the C linker would strip out all the functions that were not called, so the resulting executable was tiny. Today, each entire project and each project that it uses must be included. E.g., a small Java app often includes hundreds of jar files from other projects. Same for Javascript. And the foundation classes - e.g., the Java runtime, or Windows .Net - those are all included which makes the app really huge.
To make small apps, one has to give up dynamic loading of classes, or at least have a declarative way to specify which classes should be included in a distribution package. Either that, or pull binaries as they are needed from their source (to do that safely, signatures would have to be checked at load time, which might be too slow).
I bought an HP-41C about 40 years ago. The software (and hardware) was brilliant. Still use it and it still works. It was so well designed that even the infamous Y2K problem didn't impact it. Brilliant!
Hopefully the bar is a tad higher for developers creating heart monitors and aviation electronics is higher than the usual software (and hardware) today..
Interestingly, as much as we all hate subscription models from companies like Abode and Microsoft, those subscription models do give these companies more of an incentive to focus on stability, efficiency, and security instead of features.
How do you figure? Unless there is competitive pressure to do so they have your money and will (probably) do as little as they can get away with. Why incur extra cost if the customer is going to pay anyway? Companies with no competitive or regulatory pressure tend not to be real enthusiastic about quality since it costs money.
Source please?
He gave you the source. It was a attributed paraphrased quote. What part of that was confusing to you?
Because that sounds like nonsense. NOTHING is inherently difficult? OK then.
It sounds like nonsense because you didn't understand it, ironically proving the veracity of the statement. Just because YOU don't understand a thing doesn't mean it is necessarily a hard problem to someone else. That is you assuming that because YOU can't solve it that nobody else can either which is hubris on YOUR part.
The saying is "The perfect is the enemy of the good", meaning that if you keep trying to get to perfect, you'll never ship because most people just want good.
The problem is, "good enough" is an even bigger enemy, and we never end up with "good", instead ending up with "good enough". And "good enough" usually isn't.
Learning HOW to think is more important than learning WHAT to think.
Unix solved most of the problems associated with an operating system
Unix solved most of the problems for the mainframe or minicomputer of the Jurassic era in computing. Not so much when the micro computer came into play.in the seventies and eighties ---- and system hardware had to be realistically mass market priced at $1500-$2500 ---- at a time when 5 MB of hard disk storage could cost something like $5000.
I've never been lucky enough to work with them if they were.
defence? why would the publicly available front end of a website need to be sent securely?
Because otherwise some shithead can alter it in transit. The attacker has no need to compromise the credit card details entry form if they can compromise the flow of pages leading up to the credit card entry form.
note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
"Remember times when an OS, apps and all your data fit on a floppy?"
We always needed 2 floppy drives, DOS and Windows 2.3 included.
Tiny core Linux wasn't used by real people.
So, get rid of all the ads. Get rid of the external tracking. Get rid of logging and recording dimensional movements to the device. Oh, that affects your monetization of the application? Hmmm.,
You keep going until you die..."Me".
Java's performance has mostly been a complete non-issue for at least a decade, now.
In language a 1980s programmer would understand, a modern Java app is basically precompiled from source to intermediate object code, then gets its final round of compilation & linking when it runs for the first time on the computer where it's "installed". The "JVM" is now little more than library code that manages the heaps and runtime bindings.
When you consider how much work Windows & Linux now do behind the scenes to keep legacy C++ programs from being a security exploit waiting to happen, an average legacy C++ program NOW runs while wrapped in more of a de-facto "VM" than oldschool Java EVER did.
Writing software is expensive. Hiring cheap kids out of school because they write reams of it into the late hours of the night makes sense to MBAs who have no clue as to what they are doing. Kids out of school need to be mentored. They need to learn to look for viable, available, and tested solutions to the already solved problems before they drink a redbull and write their own whole new (and badly designed) solution. Self control is an important quality.
So, we have junk creeping in to the ecosystem and there is nothing we can do about it because no one is going to pay more for smaller software. My old android phone has 8G on it. Know what? I only have 1G usable. WTF?
I'm old. I learned to program using punch cards. I learned assembly on a 68000, 6502, 1802, 8080, Z80, 8086, and VAX. I learned K&R C before ANSI. I've used COBOL, Fortran, BASIC, Focal, C, C++, C#, Java, Python, etc. I remember looking for bytes so that my code would fit in ROM. Using 2s compliment arithmetic. Writing my own 32 bit multiply and divide for the 8080/Z80 systems.
I look at was passes for software design today and I just don't get anymore. Looking at Java or C++, it seems you have to follow a function through 5 or 6 jumps in a code browser before you get to any code that does anything. You may have 20,000 lines in your module, but it looks like only about 10 or 20 do anything useful. (Yes, this is hyperbole)
But, it doesn't matter. Users will continue to buy it. The old saying "you get what you pay for" can be taken two ways: (1) You get what you just bought for the price you paid. (2) You will continue to get what you are willing to pay for. If we use definition #2, we need to refuse to pay for crap we do not want.
To build a web app that uses Angular my build system needs to download and compile 350 megabytes of Nodejs packages. That's only just to build the application. The web app has zero Nodejs on it.
What the heck is going on?
Kriston
We built that. It's called Unix. Those who refuse to learn Unix are condemned to re-implement it. Poorly.
When I was a young programming in the early '90's, we had to develop on the oldest, slowest machines that our user base could possibly have. We used the term "eat your own dogfood". Maximizing algorithms, memory usage and performance were part of the process. Today's abundance of cheap memory and fast processes allow horrible coding. Maybe we should go back to teaching low level stuff on in 64K RAM with floppy's.
living paycheck to paycheck.
There's no middle tier because the middle class has been hollowed out and, well, the middle tier was for them. By "middle class" I don't mean the numeric definition but the more generalized one of a class that has a significant amount of discretionary income.
One thing that's important to realize is that the notion that people are "living beyond their means" is generally a false narrative used by the rich and powerful to keep you and me from questioning the system. There's tons of data to back this up. All the gains since 2008 have gone to the top 1%. Wages stopped growing (and is large swaths declined) in the 70s even as productivity exploded. Essentials like Housing and education are eating up 60+% of peoples income. The commodities market was deregulated resulting in massive food price inflation. For me, I'm going to pay approximately 50% of my income between taxes and healthcare this year and my roads are falling apart, I pay for my kid's school out of pocket and I hesitate to go to the doctor. Meanwhile my country's fighting 8 (count 'em) offensive wars (meaning wars against countries that didn't attack us).
Basically, there's a fall scale class war going on that only one side is fighting...
Hi! I make Firefox Plug-ins. Check 'em out @ https://addons.mozilla.org/en-US/firefox/addon/youtube-mp3-podcaster/
Good code should be modular, using reusable components were possible, such that only necessary modules are loaded, there is no duplication (think normalization, except in code not databases) and abstraction is based on abstract function not physical form (code has no interest in meatspace).
I reduced a NASA application from 20 megs to 360k by de-duplicating and refactoring. Performance went through the roof, defect density plunged through the floor.
Some people don't care. We in the trade call them Microsoft.
How to write tight code. Easy. NASA's Power of Ten is an excellent starting point. Top-down design, so you rip objects up into actual subcomponents, is also excellent and limits the option of thinking too much in the physical. If code is re-entrant, it makes life easier. Proper modules and libraries mean you can load and unload as needed, you don't need everything at the start.
Oh, and if you need some generic facility? That's what script engines are for. It's ok to soft-code.
Building larger programs is why I can do more on a 386SX-16 than a lot of people can do on a modern 4-core SSE3-enabled 64-bit behemoth. I can squeeze more out not because I'm better or a superhero, but because I'm using lighter software on a lighter OS, set up to be efficient.
Yeah, some might say, but we can get what we want from our expensive boxes. Why be efficient?
Same reason. Those who set up better have faster systems that end up doing more by doing less.
In a way, this reminds me of the CISC vs RISC war. RISC won, for that same reason. By doing less, you ended up doing more.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
Find a modern app that doesn't use 17 different frameworks and external libraries. Each of which ist designed to be general purpose, meaning it does more than the app needs. And each of those external libraries brings in more external dependencies, each of which... How to write "Hello, World" in only 2GB. This is modern software development, and it is seriously insane.
Enjoy life! This is not a dress rehearsal.
if founded on debt, specifically mortgages, right? And what about medical debt? Most bankruptcies are from it you know?
Class war is centuries old. It came before Marx and it continued after his death. You're strawmaning now. Throwing in the much hated SJW. Building up an enemy to direct hate at. You're either a well practiced troll or you're being manipulated by one to push their agenda. If you're just being manipulated then please, go read this. It describes the techniques being used to manipulate you. Russia's the subject of the article but they're by no means the only ones using these techniques.
Now, if you're just a troll, or worse one of the ones working for the ruling class as foot soldiers in their army, well, all I can say is that they will not treat you well after the war is won.
Hi! I make Firefox Plug-ins. Check 'em out @ https://addons.mozilla.org/en-US/firefox/addon/youtube-mp3-podcaster/
Actually, Word won mostly because it was more tightly intergrated into Windows and was able to use internal only APIs.
Yes, we know you drink Coke, not Pepsi.
I was hearing these same arguments when I started in computing in the mid 80s. And I'm pretty sure they were old and tired then. Just another variation on the same "Back in *my* day..." complaint that's been happening since the invention of language.
Chelloveck
I give up on debugging. From now on, SIGSEGV is a feature.
The use of layer after layer after layer of software in the form of frameworks that in the end add unnecessary complexity only because the lazy ass "developers" don't want to program anymore, yes the deployment times are shorter with faster-to-production times, but the final product is a bloated freak, there is also an underlying cost ... maintenance, the IT nightmare that means to maintain and stabilize those framework versions and dependent libraries, sometimes the "developers" throw in a framework just to use 2 or 3 features and that has to play nice with the other layer below.
Since the Object Oriented Programming lie that promised code re-usability but never truly delivered this has been growing exponentially and now you can find development environments so ridiculously complex that require a complete deploy of a source of 2 million lines of code to write a lame "Hello World", and sometimes even that can have bugs!
While the author, Nikita Prokopov makes a valid point, we have seen that the world is full of hackers, and those wanting all that data that resides on your phone.
The bloated apps are so because the author discovered the need to check return codes from function calls, to check that there was no corruption with the app.
Your today recent cellphone can now produce 4096 different colors in 64 levels of intensity and a pixal resolution that did not exist in devices some years ago. Therein is the majority of application bloat. Handling all the extra beauty and pixals.
Leslie Satenstein Montreal Quebec Canada
I have been complaining about this for years, I started noticing it with Adobe Reader, back in the Windows 3.1 era it was like 5mb installed, the last time I installed it, which was probably 10 years ago it was up to 200mb at that point I switched to Foxit Reader as it was miniscule compared to Adobe and even that now is up to 126mb? Why?
The Windows developers up until recently, seemed to be adding more and more crap that no-one wants and it runs like a dog, I think since it's been passed to the "Adults" as Paul Thurrott terms them in the Server/Azure team, there may be some movement on that. I have argued for ages that they would be better to decide whether it's Control Panel or Settings and get that sorted and decide what UI they want as it's a complete mishmash of differing styles. Then spend the next 2 releases adding performance and reducing bloat.
Also I would imagine the more excess code you cut out the smaller the surface area for attack, so it makes sense from that perspective. Also if you are attempting to port Windows to the ARM chips having a much slimmer and more performant O/S would make that more possible and a better experience!!
Siv
Martley, Near Worcester UK.
First, with respect to computers in general I wholeheartedly agree. Software Developers have become atrocious in their disregard for resources, and I lay that mostly at the hands of the rise of Computer Science which teaches towards the perfect computer (all RAM, CPU, storage, etc you need is there) as well as communities like Java where the motto is "just throw more hardware at it". Then you have the devs and managers that don't want to spend the time or resources to optimize the system - often going tossing out the idea of "premature optimization" in order to prioritize other things. All-in-all the software industry as a whole is just downright a disaster in this area and shows no sign of solving it any where in the next few decades.
Second, with respect the "16 GB Android phone" bit...this is more due to a change in the base Android OS and shifting to push stuff into the Google Play app store in response to phone manufacturers and telco's not keeping software up-to-date. What happened? Google wrote functionality for Android Devs that pushes requires features for one base (f.e Android SDK 24) into the app so it can run on older devices that have another base (f.e Android SDK 20). The result is app sizes bloat more and more over time - the app gets updated (f.e now requires Android SDK 28) so the layer grows; even though the app itself might not have changed much in size, the package overall jumps majorly in size. So you can't quite blame software devs on this one - it's more out of their control. If the telco's would push updates out faster and device manufacturers would actually maintain devices longer (f.e 2 yrs like they have said they would, especially Motorola) then this would be even less of an issue.
And honestly, I haven't seen 16GB as being sufficient for a very long time - even back in 2015 32GB was a far better choice.
Truth is like the sun. You can shut it out for a time, but it ain't goin' away. - Elvis Presley (source: imdb.com)
Good coding practices back then aren't any different than today.
That's not even remotely true. SOME good coding practices from back then are unchanged. Some have changed quite a lot. To claim otherwise is de-facto a claim we haven't learned anything new about coding in the last 40 years which is an assertion I reject outright.
I would argue you're typical office worker could be perfectly happy with Word 6.0 and Excel 4.0 on Windows For Workgroups. A solid WYSIWG word processing and spread sheet with easy document sharing on file shares etc. All without having to learn any cryptic commands etc.
I'm sure a lot of very productive work could be done with this sort of setup. However there are a LOT of features that have come since then that you probably are taking for granted. For example anyone who works in financial analysis (and I have/do) pretty much has to be a spreadsheet wonk and will delve pretty deep into the feature set. Many of the features we use all the time didn't exist or were very primitive when Excel 4.0 was state of the art. The features of Excel 4.0 would be VERY limiting to someone working in that industry today. It would hurt productivity badly. A lot of seemingly minor features become really important once you have access to them. That's not to say that Excel 4.0 is bad software or that good work couldn't be done with it but you really cannot credibly argue that there haven't been meaningful improvements since then.
To use a car analogy imagine its 1999 (everyone uses their mobile phone fore this now) GPS was the new hotness. It made sense from a feature standpoint to include a GPS navigation system in your dashboard. Prior to that the feature set of the typical car had not changed much from say the mid 60's. There were a few "under the hood" improvements.
A "few"? I understand the point you are trying to make but I am old enough to have driven cars from the 60s and 70s as daily drivers. If you think nothing improved between the mid-60s and 1999 in cars then you don't know cars - at least the older ones. They vastly improved safety, efficiency per horsepower, comfort, reliability, traction control, braking and quite a lot more. Carburetors disappeared in favor of fuel injection. Anti-lock braking, air bags, traction control, and more became standard equipment. Tires are FAR better as are suspensions. Corrosion control is vastly improved - cars used to basically rot underneath you. Pollution controls advanced massively. Air conditioning became standard equipment. Cars from the 60s were lucky to reach 100K miles even with careful maintenance while cars from 1999 did it routinely with fairly minimal attention to maintenance. Yes they had basically the same basic foot pedals and wheel etc but to claim nothing improved aside from a "few" things under the hood is just ridiculous.
remains at a point where the additional features you can put in are only really value adds to some - the majority don't need the feature and in a lot of cases might not even want it. These is where we are with PCs today.
Only with some pieces of software. Maybe word processing is reasonably mature but it doesn't follow that all software on PCs is equally so. And frankly I would argue even for "mature" software there probably is a lot of room for improvement not being fully realized. I can think of dozens of improvements I'd like to see in spreadsheets off the top of my head that would be of interest to huge numbers of users. Software like QuickBooks which is very widely used and ostensibly "mature" lacks whole categories of features that accountants would love to have. (I'm an accountant so I would know - for example it has no built in concept of a work order for manufacturing) And even if the feature set in these applications is fully realized they rarely are very good at collaborating with other software. To this day something as basic as copying images from one application to another is often clumsy and inconsistent even within a single office suite.
There also is the fact that while a majority of users may not need/want a given feature, some do. And the exact features that matter to a given user vary and cannot be easily predicted by the software maker. Nobody really wants to have 50 different versions o
Thank you Mr. Nikita. I have been on a similar line of thought for a few years, but every time I tried to express these thoughts I have been accused of being agains innovation, which I am not. So thank you for writing this. I will quote you when trying to make my point.
Does anyone review apps? Does anyone track bloat, in a methodical way?
Or is that irrelevant, because people won't say "No" to a bloated app, or a new version of an app that has become bloated?
Maybe if it's a commodity app -- PDF viewer, office suite (spreadsheet, word processor, etc.) -- they might pick one over another. Maybe.
There's no time like the present. Well, the past used to be.