Member of the peanut gallery here, and I fully agree with Renner1. I occasionally do front end development work, and the pace of change makes life very difficult.
Imagine someone who last wrote a Python/Ruby/C/Java application 5 years ago - they could hit the ground running and learn a few new best practices and tools in 1-2 new weeks.
Compare that to someone who wrote a JS app 1-2 years ago - they have months of catching up to do. It feels like the JS landscape is changing so fast that keeping up with things is a full-time job.
This is me. But the reason for this being the space is inundated with front-end frameworks - like there's a new one out every week. The nature of the industry is that you have to be up to date with everything. Like I had worked on Angular at one point but recently had to work on an older version and I couldn't figure it out easily. React was decent but now there's NextJs and Svelte etc.
I think this is a good description of how front-end development has become a "tool zoo", where new versions of libraries and frameworks are often radically different, and new libraries/frameworks keep popping up. I compare this to Python, where most of the time learning a new library will keep paying off for years and years. It makes front-end development an expensive (educationally) place to work, and the maintenance costs of the code are substantial.
I find it extremely frustrating that the entire build stack for frontend changes every 2 years.
It's really hard to create JavaScript apps that "just work", because you have to factor in that the whole ecosystem and community will be onto something else after 2 years, so you'll have to spend a significant amount of work adjusting your app away from outdated tooling.
That definitely used to be the case, but it seems that webdev has matured to the point where you don't need to learn a new framework every 6 months. React turns 10(!) this year, and React hooks just turned 4.
10 years, and yet any discussion on this site about front-end development will be filled with people complaining about how front-end development practices change too quickly.
I find that this is the most sane tactic as well. If you just limit yourself to frameworks with conceptual improvements (that _also_ show at least signs of substantial adoption, and preferably already are widely adopted), then the churn really is not that high. It used to be jQuery, then Angular around 2012, and now React. That's perfectly doable in terms of keeping up, at least as long as you're an actual front-end developer rather than someone who also has to do the front-end.
(And perhaps it's less so when you're older and I'm one of those darned millenials now, but I wouldn't know.)
Web dev is in a state of shit where devs are pushed towards increasingly complex and fragile stacks. The fact that you're learning Vue, micro services, docker and god knows what else just to do front end is sad and doesn't reflect on your competence or ability.
Eventually you will learn this stack but unfortunately be forced to learn a new one fairly soon. That's the real challenge with web dev: are you ready to do old stuff in new ways because trends change so fast?
I think the structure of that post is a fitting portrayal of the structure of modern frontend development... And no, I am not one of those JavaScript naysayers. In fact, I started building my first Progressive Web App three years ago.
But what I feel quite frustrated about, is the pace at which tools become obsolete. It seems that you can be happy if you have two projects which actually use the same set of tools. And every time you want to fix a bug in some project which you didn't touch for a few months, you run into some kind of trouble while updating the dependencies.
Just today, I spent an hour getting a project to build again, which I built two years ago. I just hope that in the near future the community will settle on a common set of tools which will become stable and stay for a decade or so.
I do front- and back-end web development, I have done that almost exclusively for years. It's not that skills degrade, it's that the tools evolve and change quickly, and teams move from one shiny thing to the next much faster in the front-end domain than in other areas.
Without meaning to come off as condescending or rude, if you call yourself a professional programmer and you need to put in a lot of effort to adapt to the next version of React, you aren't senior. Adapting to rapid change is part of the career, and the only difference with front-end work is the mostly self-inflicted churn. HTML, CSS, Javascript are not changing month-to-month. Web sites I wrote in PHP and jQuery ten years ago still work.
The key to keeping up with change in the software business (and it's the same, maybe worse, in the system admin domain) is to understand the core technologies and principles, which haven't changed dramatically in decades. It's far more important to understand HTTP (relatively unchanged for more than two decades) and how web browsers render (which changes very slowly) than it is to memorize every detail of how React hooks work this month. Excessive focus on languages and tools and always adopting the latest new thing is a sign of poor management and lack of focus -- and especially not focusing on delivering a product and adding business value. That can happen anywhere from the CEO on down but in my experience it mainly happens at the programmer team level, because playing with the latest dot release of Ruby or React is more fun than addressing business requirements.
As I'm by now fond of saying, no company ever had the requirement "We need 2,000 more lines of Javascript code by next month." Nor does any company have the requirement "We need to move to the version of React released last week." If that's what you're concentrating on you don't understand business requirements.
No it's not, get your facts checked. React.js for instance is 7 years old and here to stay. Angular 2+ and Vuejs are both younger but here to stay too.
Frontend dev has largely matured and stabilized, it's not the shit show it used to be anymore.
Might have to do with the fact that front end space is inundated with “frameworks” and superfluous versioning. At the same time why bother sticking with a framework that’s going to be outdated in two years because the development team moved on to something else entirely?
As an older developer (46), I stay away from the clusterf%%% of modern front end development.
In the last three or four years, I’ve been going back and forth between C# (.Net Core) using Visual Studio and Javascript (Node), Python, and Go using VS Code. The setup was. 1. Download VS/VS Code 2. Install appropriate extensions .
It makes no sense to me to try to stay up to date with front end development when front end developers are rapidly becoming a commodity with a bunch of boot camp grads. The money isn’t worth it.
Not from me, you aren't. I'm an old soldier in this game (by webdev standards of 6 months for a new framework) and I have tended to switch over to the latest stuff almost every year (projects, job change etc). It's just a common disease and herd mentality in this field to sling the latest cools. Our productivity is generally shit because instead of cranking out working code, we try to fit more tools to the box, probably to combat the repetitiveness and boredom. At the end of the day, it doesn't matter what language or frameworks we use, things still get fucked up because we never spend enough time to know the ins and outs of our tools.
The ecosystem might move fast, but deprecation in the language happen preeeetty slow.
Also, browsers usually tell you when stuff you use is deprecated.
I didn't do frontend development for years, then I got back to it with my old knowledge, ran it once through a browser and could simply modernize my browser API calls in one go.
I agree with this. While the flavor of the year frontend stack might change, since 2008 when I started dabbling in frontend, the fundamentals really haven't changed: understanding DOM, understanding the JavaScript execution model, understanding the layout models, understanding the complexities of dealing with data binding over asynchronous events and simultaneous users, and so on. jQuery didn't change any of that (although it drastically improved ergonomics). Angular didn't. React didn't either.
My experience has been that paradigms and tools can move fast and are relatively straightforward to pick up. Deep understanding of the underlying problem domain and the systems underneath the abstractions is harder to pick up, but the concepts move more slowly.
reply