I appreciate the playful tone, it's good to be reminded of these pain points after the first few layers of skin and nerve endings have burned away.
On the flip side, I can throw a hungry junior dev with a new macbook into the deep end, and they can be productive within a day. They don't have to know anything about containers, .net, nginx, or the top 100 most common command line tools. When they hit an issue they can just google it.
On the flip side, I can throw a hungry junior dev with a new macbook into the deep end, and they can be productive within a day.
Indeed. The irony is that the trade off you’ve made means that you can throw a senior dev with 20 years of experience building things that run in browsers, and he wont be up and running in a day.
He’ll be fighting all the unnecessary layers of complexity to modify this ship-in-a-bottle with the fiddly tools provided, knowing that he could have built the entire ship in a few days if he could just touch the thing with his hands.
At least that’s what I feel like dropping into Modern Frontend gigs after sprinting along on my own projects that use javascript, html and css.
Add to that any traditional server side template rendering like Jinja or Django templates, and you can implement probably 90% of today's SPAs in simpler terms and actually working browser staples like the back and forth buttons.
If your project doesn't actually need anything more complex than basic JS, html and css, you don't need those layers of complexity: you can create a new package.json based project and be productive in 5 minutes.
However, if you are thrown into an existing projects that does have all of these things, it's usually because they're actually necessary.
Everyone's experience different. Of course, if you're building a static blog, you don't need React on the front-end. However, my experience was mostly with interactivity-heavy applications, where all of these tools are not only indispensable, but often arguably not heavyweight enough.
This is such nonsense. Not everything is subjective or "an experience". There is objective truth is the world and the objective truth is your previous statement is almost never true. Unless you're operating at FAANG levels, that is, which almost nobody outside of FAANG is.
At which point they'll spend the next day or three smushing something together that they'll regret for the next ten years, and then write something like this. The cycle continues.
“Let me create a framework to handle this complexity”
Blissfully unaware that it would take them months to write that, and it would be obsolete the next day, because part of the problem is too many frameworks.
Edit: this is getting a lot of downvotes but it is important information. ChatGPT with GPT 4 ($20/month) is an artificial intelligence that can save hours of your time and help you debug things you couldn’t without it. It really understands code.
While I will take a 4 point karma hit from downvoters who don’t know how to use ChatGPT, this information is very important to share with all programmers.
>stochastic parrot
This is incorrect. In the context of learning JavaScript, ChatGPT with GPT 4 ($20/month) can analyze any error if you give it the error and the code, or you can just describe what’s wrong and give it the code you wrote and it will analyze it and tell you how to correct it, even if your code is the first time anyone has done that. It might take it two tries but it’ll figure it out. It obviously understands what you tell it and follows your instructions pretty well.
Limitations: the code you give it has to be small; ChatGPT doesn’t scale to larger codebases.
Second limitation: if you happen to be a world expert in something, then it might have trouble understanding - haha, just kidding: if you are the best human expert in the world, ChatGPT is still smarter than you and can still fix errors you can’t fix.
Rather than a stochastic parrot, it’s the best debugger on the planet.
In fairness you are correct that ChatGPT is unreliable.
People have no idea what AI is, they seem to go entirely off of the name. An intro course in Natural Language Processing reveals that while impressive, GPT-4 is a reflection of the training data. It is not conniving, it does not cause harm. The medical benefits alone are staggering.
What we are about to do, as a self-inflicted wound, is let a lot of simple algorithms make real decisions as cover for plain human cruelty. The software platforms landlords are using to collectively raise rents are already an obvious example.
Guaranteed income is a form of stability, which changes the outlook of recipients far more radically than a one-time transfer. People are more likely to make plans that increase their productivity in the future, such as fixing vehicles, going back to school, or leaving under-employed situations. The price fixing you describe already happens as much as possible, that's what drives inflation. UBI lets people walk away from bad jobs and re-distributes agency so that nobody is trapped.
If I knew every person had a guaranteed income, I would have a lot of business ideas that would be radically more feasible. It would be much easier to borrow against a portion of one's future income and secure capital.
Has this author been on the other side of the fence? I have encountered, for every bloated javascript problem child, an equally burdensome python monolith, or sprawling maze of go microservices. I suspect the root cause is something to do with human error, but I digress.
The benefit of much-derided React code when I can onboard new developers from 3 different countries and backgrounds and have them all writing DRY, tested, idiomatic code within a few days. They can then ship a feature that then provides more values to the end user, who probably doesn't care a fig what HTML is. Or, like a patient senior developer, they understand that shipping is preferable to not shipping, and that perfect performance, accessibility, and usability are all asymptotic to us mere mortals.
We are replacing truly the most disgusting codebase I've ever seen right now, a WP instance (alright) highly customized (worrisome) written by pre-for-loop contractors (uh-oh) which has over 10k lines of jQuery (uh-oh) for a relatively small site, but all of the jQuery lives in one main.js (UH-OH) and executes on every page whether or not it does anything to that page. It's also written in such a way that it crawls the DOM so many times on huge HTML payloads that the entire page slows to a crawl as your computer fan winds up. You'll often get 10 seconds of non-responsive page after the first paint. There's barely any interactivity here as well, just a couple of modals and buttons.
As the client scaled up, they started having serious performance problems that rendered the site completely unusable for some users, and some pages were so bad on the backend that simply visiting a page could cause an outage. Refactorings were considered (minor ones attempted), but the code is so poorly written and brittle that it's actually easier to just fucking rewrite it, so they/we just do targeted performance enhancements, bugfixes, and minor updates while rewriting.
All that to say, the worst codebases I've ever seen are PHP monoliths, (though I've seen some rough Django/flask as well) shitted out by contracting firms which bill high rates for code written by juniors. People (particularly those who frequent this site) are way too focused on the choice of framework when trying to assess these outcomes.
Yes, yes, yes. I have bought a screen and plan on integrating exactly this sort of setup into my routine, mainly for the focus benefits the author notes.
I get the impression making a web app was considerably more difficult for a solo developer pre-jQuery. For a while we had an explosion of choices, and ultimately things coalesced around React and similar paradigms. Meanwhile the per-capita productivity has been skyrocketing as increasingly sophisticated cloud services provide everything from raw key-value storage to turnkey caching and auth solutions.
Is it more complex than single-device programming? Perhaps, but the modern browsers represent a nearly universal platform with very low per-user complexity.
Where the majority of the complexity was in the backend. Now, the complexity has simply moved.
I'm quite happy I don't need to have two different codebases in different languages for most things anymore. I'm more than happy to offload it to the browser to save me some effort, time and money.
You have to validate on the backend among other things. Honestly the only thing we have nowadays is flashier websites for the most part. Some very small percentage of websites actually require the tech that has been built despite the fact that nearly all engineering teams seem to push for it.
On the flip side, I can throw a hungry junior dev with a new macbook into the deep end, and they can be productive within a day. They don't have to know anything about containers, .net, nginx, or the top 100 most common command line tools. When they hit an issue they can just google it.