Your job isn't to build the smoothest, most optimized, experience for your customers. It's to build features customers want or need, which in turn create value for your employer. This generated value pays your paycheck. Of course if you do a bad enough job, it's counterproductive, but to the extent it's not bad enough your job is to focus on features and development and not on optimization. Once performance is bad enough, your job becomes optimization -- via instrumentation, measurement and profiling.
Every minute you spend waiting on a build or waiting for an app to launch or waiting for some long-running task to finish is a minute you're not creating value. Compounding this problem, it impacts morale if you spend your day looking at spinning beach balls while your boss won't get off your back about when you'll be done.
This is your employer's perspective, more than likely.
[edit] Another way of looking at this is to say that you and your customers are doing different jobs. You have all the extra cpu and memory overhead of developing a product — all they have to do is run it. By definition your workload is more demanding.
And, this is a personal anecdote of course, but sometimes having fast machines can paper over problems that you should really be addressing: I had a coworker once who temporarily used a fairly (~7 years) old machine to do their development work until they could get something newer to work on. During that time I noticed that they would take a while to make minor fixes after reviews. I asked them why and they told me that they would make the change and then they'd build it and it was taking dozens of minutes–it turns out that there was a creeping dependency tracking issue in the build process that nobody had bothered to address yet because it didn't seem like a huge issue on our normal machines. But fixing it certainly got his turnaround time way up, and the CI machines really liked the change too ;)
Or you should -know- what specs your users are using (this is really not hard) and optimize for that.
You can get chrome to degrade network performance etc. It's not easy to downgrade machine performance tho.
I can count on one hand the number of companies I've worked at in the last decade who had in-house QA teams. Most companies just rely on the developers to test their (our) own code. The exceptions are banks, gamedev companies and big corp products (like Windows).
Most web software I've seen - especially in the startup world - just assumes that "it works well enough on the developers' specced out mac" means it works. The most tragic version of this I saw was our app looking awful on a ‘normal’ 19” desktop monitor. The problem was our designers did all their work from 27" imacs. They never thought to design and test on smaller displays. Or the designers placing adjacent colors that look great on color graded displays but are almost indistinguishable on the trashy 6 bit TN displays that were ubiquitous in offices a few years ago.
Even in companies with dedicated QA I haven't seen many tickets of the form of "the program runs slowly on this old computer we have". Sadly the creeping performance rot is mostly invisible.
Honestly, people running slow computers are probably just used to poor performance. I fully agree with you that we should do something about it but I don't see that happening unless it's a strong priority (feature X/y/z or performance? is usually the conversation).
Anecdotally: I'll never forget the first time I launched an app from an SSD and vowed I was never going back.
It's not as easy to do this as it could be, but it's not that hard either.
It doesn’t have to be either/or, it can be both. Developers absolutely should be using their own software frequently, seeing and feeling how well it performs; trying it out on a lower-spec machine is always a useful exercise.
That doesn’t mean you can’t also have dedicated QA. Developers shouldn’t have to be in charge of QA, but they should have some involvement.
Hypervisor / virtualization tech should mean you get very close to actual host OS performance. Otherwise this whole container thing wouldn't work so hot?
yes > /dev/null &
Repeat until slow ;)If you fail to make those consistently you end up with large infrastructure bills and unhappy customers eventually.
That is literally my job! You should have someone like that too, or else you'll end up shipping an Electron app like Discord does.
And get to dominate their market niche?
People got to realize while native apps are nice and all, there is absolutely zero evidence that going native vs cross-platform improves any metric a business actually cares about. Users are flocking to cross-platform apps in droves!
Vocal message board users screaming their preference for native apps are not in any way a significant share of the actual market for these applications.
I seriously doubt the use of Electron is what's driving that.
And it's also worth remembering that "cross-platform" ≠ "bundle an entire web browser in the app". Qt exists, as one of many examples of application frameworks/toolkits that are simultaneously cross-platform and native.
It is indirectly driving that.
Using Electron instead of other cross-platform frameworks like Qt allows one to work faster since you can apply webdev knowledge, and that directly leads to features that users actually care about being delivered faster.
Like, if you just need to spit out a prototype to hit the ground running fast, then fine, but long-term there are pretty clear benefits to using the right tool for the job.
The "work faster" argument is pretty dubious on its own anyway; yeah, maybe web devs ain't particularly productive with Qt or similar frameworks, but desktop devs absolutely can (and arguably should) be productive with such a framework.
There is no evidence to believe that users are concerned about RAM usage to any level that would move them over to competing apps.
> The "work faster" argument is pretty dubious on its own anyway; yeah, maybe web devs ain't particularly productive with Qt or similar frameworks, but desktop devs absolutely can (and arguably should) be productive with such a framework.
There are orders of magnitude more web devs than devs who are even just familiar with desktop GUI toolkits. Even if you can find people who are just as productive with (for example) Qt, they'd be (way) more expensive than the average web dev.
And, again, now you have less budget to spend on things that actually gets you users.
Do you know that writing code efficiently can also save money for the company? If you try to write code that burns bandwidth or CPU cycles without even attempting to optimize it, it's gonna cost you an eye at the end of the year.
Software optimized for the slowest hardware possible actually does saves money, which helps also to reach the goal of doing more money, since more hardware is being supported, not only the cutting-edge one.
I've seeing now this infamous trend also on Android Phones boosting 90-120 Hz screens. If applications get optimized to run on these phones, whose CPU is also strong, obviously older phones are suffering and become sluggish.
Seriously, try to write code as your target platform is a Raspberry Pi 1 model. If works on it fast, it's going to be fast everywhere
Those managers were eventually all let go and one of the first things new management did was buy us the most powerful machines they could find and institute performance regression tests that rachetted down. Each change could only keep the existing performance or make it faster. And changes that made it faster set the new watermark. Regressions required management approval.
After performance having been unimproved for a year, it was largely resolved in 6 months.
Since then I’ve been a believer that you give your developers nearly the fastest platform money can buy but then have automated, gatekeeping tests for your lowest target platform, with spot checking to make sure your tests reflect actual user experienced performance on that platform.
at our BigCo these days we have a modern, dare i say Cloud Native, version of this stupidity - developers can't get even minimally powerful and reliably provisioned cloud resources (while the official rationale is similar to what you described the real one is much worse - it is just penny pinching). So it isn't just slow and unreliable, the real humongous cherry on top is that it has very short lifetime enforced by automatic deprovisioning - thus even when you finally were able to spin up our platform - which is far from guaranteed and may take many attempts as the platform is the product what we're developing, and it naturally has issues, etc. - and now you're happy and ready to start working on it, and at that moment it all disappears because of that short lifetime enforcing automated deprovisioning. Thus not surprisingly the results are exactly as you described - despite the management running around chanting cloud!cloud!cloud! our products' cloud story has so far made it practically nowhere .
I live in a world where I cannot make performance evaluations based on my benchmarks on my "normal" build- I have to switch to a release build and recompile everything in order to make performance determinations. This led to my first personal experience of "premature optimization is the root of all evil". I implemented a new feature, performance was completely fucking untenably awful, so I threaded it. Performance was still awful, but it was 7x better because I has 7 free cores (8 total cores) to play with. I thought great, I tested, I found the bottleneck, I bandwidthed the fuuuck out the bottleneck, problem solved. A few weeks later I was testing on a release build, and in the same feature, the aforementioned bottleneck was using roughly 5% of the total CPU usage. Because the optimizer just - fixed all the slow stuff. The bottleneck that I threaded the shit out of didn't contribute significantly to the total CPU usage of the release build, while it was 87.5% or whatever of the debug build. And in the release build, I'm pretty sure all the threading overhead I added took away any and all benefit.
The thing I learned from that experience was to ignore all performance problems unless I observe them in a release build. If I had a faster computer, it would be significantly easier for me to switch back and forth between release and debug builds. And I would thus be able to observe performance problems easier.
I imagine there's a significant divide between front end web development and desktop application development here.
If you have a computer fast enough to do a release build quickly, it’s probably also fast enough to hide performance problems with the release build.
There are other approaches that can work, like building in the cloud so you don’t need a huge fast PC for each developer, or doing partially-optimized builds that balance build time with runtime (and debuggability).
This. And if it could also throttle CPU performance, painting performance, and available cache memory to a "typical user" profile that would be ideal.
It would be best of all if that typical profile varied from day to day to cover a range of experiences of typical users, but the distribution was updated periodically from the lower quartile of the general web user population as measured by surveys.
In general: Fast developer machine for builds, slow runtime machine for using the application.
(In embedded and console games this has always been automatic :-)
If you don't run the application on a separate machine, then simulate one instead.
But there's no advantage in making IDEs, compiles and testsuites run slowly. Just the target application.
I'm not quite sure how much Apple shared publicly, but there was an iOS version that caused huge performance hit for older phones (honestly, it's kind of common with new major versions, but this was an outlier). They had a .5 release that tried to improve performance. My understanding is that, like you said, developers had been developing on the newest hardware. Apple seems to be more sensitive to this and it's not because performance for phones have plateaued, but I've noticed specific regressions here and there. I remember one iPhone specifically demoed how fast the camera launched. After a few OS updates the performance was as miserable as the phones they had been mocking.
I know console developers deal with this, too. Their SDK hardware has more RAM than production hardware, but their tools generally have big flashing alarms when you exceed the memory used in production.
I eventually helped design and deployed high quality LTE modems, which were awesome (with the right antennas, internet was good even in places where a phone would show no signal... but obviously the boonies on land are different than at sea!)
This is also part of the reason I am so cli/tui focused. I want to be able to run a full environment from ssh. (screen and mosh help with disconnects and instability)
Product managers and designers should use average equipment for their target market.
Your equipment should allow you to do your job better, not show your rank.
The other thing to consider is that when you’re hiring software engineers, your competing with everybody else who’s also trying to hire software engineers. So if a candidate sees all your engineers using a laptop that they don’t want to use, they’re likely to take that into consideration when deciding whether they want to work for you. Expensive laptops, free food/drink, a gym, free massages, and all of those other perks you might find in software companies sound extravagant, but they’re such an easy and cost effective way to compete with other employers.
My work desktop is over 5 years old and still perfectly usable.
If we happen to get a customer laptop from their IT for accessing their internal network instead of some cloud instance, you can bet it is most likely fitted with 8GB and a regular HDD.
It is only on HN and Reddit bubbles that I get to see people using the very latest and greatest.
Ah, and I was part of a project a couple of years ago, where teams focused on Windows machines and literally timeshared iMacs and the respective iDevices for testing their hybrid apps.
Then again, even if a developer cares about performance, if it's not set as the main goal or given any resources to pursue, it will still not get the much deserved attention.
Performance on lower grade consumer devices should absolutely be a minimum pass criterions, but if it isn't, giving developers older devices will not help.
I’ve worked at several production companies, games & films, that had policies of giving devs the worst machines. The thinking being that artists who use the tools should always feel less pain than the devs who make the tools, not more.
Not sure what that dollar figure looks like though.
I'm writing this on a 2011 Mac. Well maintained.
- First of all, faster hardware means better productivity. If you want the developers have time to optimize for speed, better give them the time for this. Cutting their productivity usually means, less time is spend on optimizing, all "features" need to be implemented first. Only when all "features" have been implemented, quality improvements get scheduled. You want developers to be productive enough that they get time to improve quality/speed.
- Developers are running the application completely differently than the end users. If an application is run for hours if not even days at a time, startup speed doesn't count much. A developer might have to restart an application for debugging something every minute[1]. Having the developer waiting on startup would be a bad waste of time. While it might be nice to optimize startup times, the really might not be customer-relevant.
- Developers often run unoptimized code with debug code present or even inside a debugger. This makes the code often slower than the customer experience.
- Developers might have to run several instances of the application at the same time, requiring the neccessary compute resources, also the development environments need to be powered.
- And to some extend, which gets revived by the power of these new chips, development often happens years before a product ships. What is an exotic and expensive machine at the project start, might be a medium range for the customer when the product ships. So the development machine was actually a good match of the deployment platform.
These are some of the reasons why developers should have powerful machines. Of course, there are also a lot of reasons to test the product on less powerful machines and set performance goals according to these tests. But this doesn't mean the developer has to do the development work on those machines. If a product doesn't get tested enough and on the right systems, it is rather a project management issue.
1: I am fortunate to do quite a bit of my work in Lisp and it is one huge productivity boost that I can update every single function redefinition in the running code. Which gives me increadibly short iteration cycles. The cost of starting up an application to test a change isn't just the startup time but also the interaction needed until you get to the point where the function is called, I am doing quite UI-centric work. This becomes very noticable, whenever I actually have to restart the application to get a meaningful test. Even worse are the situations where I even have to wait for a longer compilation run (with non-Lisp languages, like C++)
It’s clear that all of these things never get tested beyond the high-powered machine that the developer used. And I don’t see the trend of developers being completely out of touch of what devices their users are using going away anytime soon. But maybe we should start considering “experience correction” tools as part of a regular testing methodology. A friend of mine once lamented that the web would be a much better place if opening the Chrome developer tools automatically enabled the network throttler, and I think I’d have to agree with him.