Things that used to be hard and are now easy(jvns.ca)
jvns.ca
Things that used to be hard and are now easy
https://jvns.ca/blog/2022/02/20/things-that-used-to-be-hard-and-are-now-easy/
305 comments
I would also add something along the lines of "building big webapps". Large frontend codebases used to be scary Lovecraftian horror where things were only touched out of utmost necessity. Runtime errors for weird corner cases. Dangling dependencies that no one could figure out whether they're safe to update/remove or not. Refactoring was both an art and an arcane incantation at the same time. Modern tooling and best practices have made most if not all of these problems nearly non-existent, and I'm grateful for it.
> Things that used to be hard and are now easy:
> Concurrency, with async/await (in several languages)
The number of times I've been bitten by the very specific semantics around async/await in JavaScript makes me wonder if I've hit some kind of a ceiling in trying to grok it.
Coming from the world of threads, I've found Kotlin's structured concurrency approach the best of the lot I've used so far, even if it isn't with out its quirks: https://kotlinlang.org/docs/composing-suspending-functions.h...
> Concurrency, with async/await (in several languages)
The number of times I've been bitten by the very specific semantics around async/await in JavaScript makes me wonder if I've hit some kind of a ceiling in trying to grok it.
Coming from the world of threads, I've found Kotlin's structured concurrency approach the best of the lot I've used so far, even if it isn't with out its quirks: https://kotlinlang.org/docs/composing-suspending-functions.h...
As someone who leans frontend, I find firebase and serverless (somebody else’s server) solutions really powerful for prototyping an idea or building a proof of concept. You can get something in front of your users tomorrow. I would second guess SaaS startups that start by building the infra/data models unless they’re going for a highly technical play (aerospace, hardware, etc) or already have a ton of market knowledge.
I’m in the middle of a mongoDB to Postgres migration for a product with 0 users. When you’re trying to scale from 0 to 1 user then everything should help you explore the user’s problem space, even if it seems backwards to build the UI before the backend.
I’m in the middle of a mongoDB to Postgres migration for a product with 0 users. When you’re trying to scale from 0 to 1 user then everything should help you explore the user’s problem space, even if it seems backwards to build the UI before the backend.
I would love to see the reverse of this 'things that used to be easy and are now hard'
That would be an interesting read
That would be an interesting read
There's another facet I've watched with interest:
>> Building videogames, with Roblox / Unity
This has resulted in something like 90 new games entering Steam every day. While some games may still be art, they're increasingly difficult to find among the noise. I've heard the mobile game market is in worse shape[1] by the deluge of games. "More games for everyone!" sounds great - but note that definitely doesn't mean more "good" games - or more "innovative" games all the while encouraging rampant copying/stealing of ideas.
[1] https://www.youtube.com/watch?v=Q30qZSEnI9Q
>> Building videogames, with Roblox / Unity
This has resulted in something like 90 new games entering Steam every day. While some games may still be art, they're increasingly difficult to find among the noise. I've heard the mobile game market is in worse shape[1] by the deluge of games. "More games for everyone!" sounds great - but note that definitely doesn't mean more "good" games - or more "innovative" games all the while encouraging rampant copying/stealing of ideas.
[1] https://www.youtube.com/watch?v=Q30qZSEnI9Q
Writing GUI apps for Apple products.
Too many variables to mention, but I wrote my first Apple application in 1986. It took several weeks, and wasn't much to look at.
These days, I can spin out a full-fat, shippable app, in a couple of hours. I do that all the time, for my test harnesses.
Too many variables to mention, but I wrote my first Apple application in 1986. It took several weeks, and wasn't much to look at.
These days, I can spin out a full-fat, shippable app, in a couple of hours. I do that all the time, for my test harnesses.
Regarding chocolate quality discussions: when Hersey started up, they couldn't get any European chocolatiers to share their process, so they had to invent one. They used lipolysis, which creates butyric acid, the chemical that gives vomit its distinctive smell and aftertaste.
You can definitely taste it if you pay attention, like "yep, that's it, it's that vomit aftertaste."
https://www.google.com/search?q=hershey+vomit
You can definitely taste it if you pay attention, like "yep, that's it, it's that vomit aftertaste."
https://www.google.com/search?q=hershey+vomit
“Everything” that is easy used to be hard, depending on your time scale.
I’m certain that COBOL programmers were raving about the ease with which you could program the computer back in the day.
The items on this list sort of happen within a career so an individual had to experience how hard it was before. It probably reads different to someone coding for 5 years vs 30 years.
I’m certain that COBOL programmers were raving about the ease with which you could program the computer back in the day.
The items on this list sort of happen within a career so an individual had to experience how hard it was before. It probably reads different to someone coding for 5 years vs 30 years.
I would also agree to this in MANY fronts, not just software. As a kid I dreamt of building a robot at ~6 years old. Just this past weekend, I helped my God-son build one (a solar kit for kids) and it was on sale for $10.
Things are generally more affordable now than they used to be for the masses, and more easier to achieve and prototype, in less turn around time, with 1 day shipping, or the mall-ification of society.
Cool stuff really.
Things are generally more affordable now than they used to be for the masses, and more easier to achieve and prototype, in less turn around time, with 1 day shipping, or the mall-ification of society.
Cool stuff really.
I've only been using desktop Linux for 15 years, but it is vastly easier to use it as a daily driver than it used to be. It still has its problems--just yesterday I sunk an hour into an elusive bug. But when I was doing that, I remembered that such things used to be nearly constant and aren't any longer.
IE support for JS/CSS has been massively simplified by not supporting IE any more.
It's very hard to accept the statement that writing fast programs is now simpler with Go/Rust. I think that what happened is more like this:
* With Go is now possible to write reasonably fast (not as fast as C) programs in a simpler way. That's great indeed, but is not exactly the above statement.
* With Rust it is possible to write programs that have a speed that is comparable to the one of C programs, that are memory safe. So Rust made memory safety simpler, but writing a fast program in C is often simpler compared to writing a fast program in Rust, if we ignore memory safety. Overall Rust made programming harder: something that I'll hardly excuse to it.
EDIT: The blog post was modified, so it only lists "Go" in the section about fast programs. My comment refers to the version of the blog post I read.
* With Go is now possible to write reasonably fast (not as fast as C) programs in a simpler way. That's great indeed, but is not exactly the above statement.
* With Rust it is possible to write programs that have a speed that is comparable to the one of C programs, that are memory safe. So Rust made memory safety simpler, but writing a fast program in C is often simpler compared to writing a fast program in Rust, if we ignore memory safety. Overall Rust made programming harder: something that I'll hardly excuse to it.
EDIT: The blog post was modified, so it only lists "Go" in the section about fast programs. My comment refers to the version of the blog post I read.
Would be interested in also seeing a "things that used to be easy but are now hard list". Feels like basic stuff is harder now:
* Privacy online
* Google search for niche or exact matches
* Browsing without captchas and blockers, especially if you don't adhere to big tech's rules for the internet
* Sending emails without worrying about spam filters being way too aggressive
* SEO before it got hacked to hell
* Barrier to entry for creatives to build things on the web (for all the flaws flash had, it bridged the gap)
* Finding real discussion and information. The growth of bots posting, misinformation, blogspam, and toxic echo chamber partisan discussion online (maybe it was always like this, i.e, eternal September?)
* MacBooks being easier to upgrade before when things weren't soldered on
* In general anti right to repair hardware
* Not having to worry about dongles, i.e. connecting USB devices to your machine
* Ransomware wasn't a thing. Nothing like a non-technical user needing to learn BTC or XMR to maybe get their data back
* Being able to buy software once vs a subscription, e.g., photoshop
* Work was easier to disambiguate from life before chat apps like Slack made employees always reachable
* CGNAT not being as common
* OAuth is still annoying to implement
* Blocking ads was easier
* Getting a job was easier for a lot of people prior to whiteboarding, leetcode tests, assignments, multi-day interviews and trials, etc. becoming more common
* GDPR making infra+dev work harder because big tech companies don't understand consent and couldn't behave, also leading to performative/annoying cookie banners we see everywhere
* Needing an internet connection for software+tools that used to be able to run locally on your OS
* Website responsiveness was easier before all the devices and monitors with different viewports
* Archival (or scraping) was easier before the majority of human generated content was placed behind login walls (fb) and rendered content needing headless browsers
Edit: Call me cynical if you want—yeah some of those programmer things listed are easier now, but improvements on the core regressions I listed would help programmers (and non-programmers!) all across the world and in developing countries more than some niche highly paid SV engineers using terraform to orchestrate infra on GCP.
* Privacy online
* Google search for niche or exact matches
* Browsing without captchas and blockers, especially if you don't adhere to big tech's rules for the internet
* Sending emails without worrying about spam filters being way too aggressive
* SEO before it got hacked to hell
* Barrier to entry for creatives to build things on the web (for all the flaws flash had, it bridged the gap)
* Finding real discussion and information. The growth of bots posting, misinformation, blogspam, and toxic echo chamber partisan discussion online (maybe it was always like this, i.e, eternal September?)
* MacBooks being easier to upgrade before when things weren't soldered on
* In general anti right to repair hardware
* Not having to worry about dongles, i.e. connecting USB devices to your machine
* Ransomware wasn't a thing. Nothing like a non-technical user needing to learn BTC or XMR to maybe get their data back
* Being able to buy software once vs a subscription, e.g., photoshop
* Work was easier to disambiguate from life before chat apps like Slack made employees always reachable
* CGNAT not being as common
* OAuth is still annoying to implement
* Blocking ads was easier
* Getting a job was easier for a lot of people prior to whiteboarding, leetcode tests, assignments, multi-day interviews and trials, etc. becoming more common
* GDPR making infra+dev work harder because big tech companies don't understand consent and couldn't behave, also leading to performative/annoying cookie banners we see everywhere
* Needing an internet connection for software+tools that used to be able to run locally on your OS
* Website responsiveness was easier before all the devices and monitors with different viewports
* Archival (or scraping) was easier before the majority of human generated content was placed behind login walls (fb) and rendered content needing headless browsers
Edit: Call me cynical if you want—yeah some of those programmer things listed are easier now, but improvements on the core regressions I listed would help programmers (and non-programmers!) all across the world and in developing countries more than some niche highly paid SV engineers using terraform to orchestrate infra on GCP.
Until "large prime factorization" makes this list, I think we're cool.
Personally, I disagree that parsing was hard before and made easy with PEG parsing.
For decades it has been easy and common to implement parsers by hand.
From what I can tell, universities and textbooks just overcomplicated the process by teaching parser generators.
I have done a few studies of various open source ecosystems now and (edited: other than CPython) I haven't seen PEG parsers really used in anything but toy implementations of things.
For decades it has been easy and common to implement parsers by hand.
From what I can tell, universities and textbooks just overcomplicated the process by teaching parser generators.
I have done a few studies of various open source ecosystems now and (edited: other than CPython) I haven't seen PEG parsers really used in anything but toy implementations of things.
Rounded corners and gradients on the web. When I started both required background images, now they are just a css property.
Fun list. The only nitpick I have is for Spark. I would not consider it easy at all. From my experience, team members that needs to come up to speed on Spark usually take about a month to do so.
Eh... I'd argue against quite a lot of those being "easier" than doing things manually.
Docker is a prime example. It's supposedly easier to spin up a docker container for a basic web server stack, but to be honest I'd rather install PHP/MySQL and an SSL certificate manually, rather than spend time finding a decent container from a trustworthy source, and then spend 20 minutes trying to figure out how and why it's been configured the way it has, etc. etc.
Plus there's the need to actually install docker itself and learn how to use it in the first place.
Every one of these comes with its own learning curve which isn't always better than just learning how the actual tools underneath work.
Docker is a prime example. It's supposedly easier to spin up a docker container for a basic web server stack, but to be honest I'd rather install PHP/MySQL and an SSL certificate manually, rather than spend time finding a decent container from a trustworthy source, and then spend 20 minutes trying to figure out how and why it's been configured the way it has, etc. etc.
Plus there's the need to actually install docker itself and learn how to use it in the first place.
Every one of these comes with its own learning curve which isn't always better than just learning how the actual tools underneath work.
The first commercial game I ever designed was built on a custom made 3d render. All sorts of things you do in harware now had to be done in code and you could seriously push like 1k triangles at 20 fps. And that was really good! It took the smartest programmers I have ever known to get that to work on a 486.
Now you have Unity, Unreal and hardware acceleration.
Now you have Unity, Unreal and hardware acceleration.
Developing for mobile is so much easier overall with the Ionic framework.
It's not for every application but I would say most applications it's great for. My first startup we needed iOS, Android, and web teams. For my current startup, we have one frontend team using Ionic/Angular and we just deploy to all 3 places with the same codebase.
It's not for every application but I would say most applications it's great for. My first startup we needed iOS, Android, and web teams. For my current startup, we have one frontend team using Ionic/Angular and we just deploy to all 3 places with the same codebase.
NLP with HuggingFace
> Cross-compilation (Go and Rust ship with cross-compilation support out of the box)
That's not right? Go has builtin cross-compilation. Rust does not, you need to bring your own cross toolchain even after adding rust-std for the target with rustup, unless there are recent changes I'm not aware of.
That's not right? Go has builtin cross-compilation. Rust does not, you need to bring your own cross toolchain even after adding rust-std for the target with rustup, unless there are recent changes I'm not aware of.
While I agree that many of these items are way easier than before, it still comes at a cost. Making a lot of these things easy has actually caused new problems that are once again, hard, mostly because of emergent complexity. For instance - configuring cloud infrastructure declaratively has made it very easy to stand up vast numbers of computational instances and distributed systems that now have to be reasoned about, monitored and managed effectively. CI/CD pipelines means we are able to deploy code way more quickly and efficiently and with less manual testing, likewise causing an explosion in complex business logic that's been deployed. If you're not careful, the complexity enabled by these developments can quickly overwhelm you and your team.
[deleted]
I find the serverless frontend to be way more tedious than a monolith approach.
Wow! Let me continue :)
- Text-to-speech and vice versa, using cloud APIs. - creating a solid objects from 3D models (3d printing) - messaging: pub/sub, message buses (kafka, redis, postgresql channels, rabbitmq etc) - advanced data structures are more available (sets/hashes/etc now in standard libraries of any language, and in many databases)
Things that surprisingly still a pain: - scanning documents preserving formatting (there are niche solutions but they are too expensive for a person who needs it a couple times a year)
- Text-to-speech and vice versa, using cloud APIs. - creating a solid objects from 3D models (3d printing) - messaging: pub/sub, message buses (kafka, redis, postgresql channels, rabbitmq etc) - advanced data structures are more available (sets/hashes/etc now in standard libraries of any language, and in many databases)
Things that surprisingly still a pain: - scanning documents preserving formatting (there are niche solutions but they are too expensive for a person who needs it a couple times a year)
One thing, I will like to add this. Learning new things and gaining mastery has become approachable too. Note, it is approachable, and as gaining mastery is intensely personal endeavor.
Learning new things via youtube, coursera, udemy, udacity, edx, many things. Mastery via project based learning, Github, tests in courses, certification exams, exercism, etc.
Learning new things via youtube, coursera, udemy, udacity, edx, many things. Mastery via project based learning, Github, tests in courses, certification exams, exercism, etc.
Perhaps a good follow-on thread would be new things that have solved multiple other things that use to be hard or impossible.
For example, Rust comes to mind as something that has improved error messages, elimination of most memory-related bugs and "fearless concurrency." All while being fast and having support for cross compilation.
For example, Rust comes to mind as something that has improved error messages, elimination of most memory-related bugs and "fearless concurrency." All while being fast and having support for cross compilation.
The general theme of this list is that technology gives us more and more hoops to jump through, then provides some trampoline to jump through them. We're supposed to be eternally grateful. I'm not. I want to focus on problem-solving, not masterfully using trampolines.
> SSL certificates, with Let’s Encrypt
Semi-mandatory SSL certificates weren't a thing on the web until fairly recently. Not managing them at all was certainly easier than managing them with Let's Encrypt, which has a lot of gotchas, requires tooling, knowledge and can suddenly break your website if something is off.
> Concurrency, with async/await (in several languages)
async/await usage is literally the main reason why my recent project is written in Go instead of C#. I like C#. I don't like Go. But dealing with all the gotchas of .NET Core async/await APIs drove me away.
Moreover, Erlang had a much more sane and powerful parallelism model way before async/await.
> Centering in CSS, with flexbox/grid
Again, like with SSL, this is technically correct, but generally incorrect. Centering in CSS has gotten much easier with flexbox/grid. However, centering in HTML only became hard because tables were abandoned as the layout mechanism. Sure, they're not "semantic". But we're talking about what became easier, right? Not about what became more ideologically correct, semantic, etc.
> Configuring cloud infrastructure, with Terraform
Again, there used to be no Cloud infrastructure to configure. Personally, I find Terrafrom annoying more than anything else.
> Setting up a dev environment, with Docker
As opposed to doing what? Keeping my dev environment simple is a constant battle and most of the time Docker is the weapon used by the other side. In 00s my dev environment was a text editor and some upload tool.
I haven't used PHP in well over a decade, but for my latest personal project I've decided to brush up on PHP 8.1. Despite awful syntax, I can do stuff by writing a handful of lines of code in a text editor. It's very refreshing. 100% focus on the outcome rather than tooling.
> SSL certificates, with Let’s Encrypt
Semi-mandatory SSL certificates weren't a thing on the web until fairly recently. Not managing them at all was certainly easier than managing them with Let's Encrypt, which has a lot of gotchas, requires tooling, knowledge and can suddenly break your website if something is off.
> Concurrency, with async/await (in several languages)
async/await usage is literally the main reason why my recent project is written in Go instead of C#. I like C#. I don't like Go. But dealing with all the gotchas of .NET Core async/await APIs drove me away.
Moreover, Erlang had a much more sane and powerful parallelism model way before async/await.
> Centering in CSS, with flexbox/grid
Again, like with SSL, this is technically correct, but generally incorrect. Centering in CSS has gotten much easier with flexbox/grid. However, centering in HTML only became hard because tables were abandoned as the layout mechanism. Sure, they're not "semantic". But we're talking about what became easier, right? Not about what became more ideologically correct, semantic, etc.
> Configuring cloud infrastructure, with Terraform
Again, there used to be no Cloud infrastructure to configure. Personally, I find Terrafrom annoying more than anything else.
> Setting up a dev environment, with Docker
As opposed to doing what? Keeping my dev environment simple is a constant battle and most of the time Docker is the weapon used by the other side. In 00s my dev environment was a text editor and some upload tool.
I haven't used PHP in well over a decade, but for my latest personal project I've decided to brush up on PHP 8.1. Despite awful syntax, I can do stuff by writing a handful of lines of code in a text editor. It's very refreshing. 100% focus on the outcome rather than tooling.
How about things that used to be easy and now are hard?
Or things that used to be hard, and now are intractable?