How do you cope/work with endless cycle of webdev?

I cope by only using tech that has been battle tested, solves a problem and proven to last for a long time to come.

Most people still use REST APIs. GraphQL is cool, sure. But it solves a very particular problem. Why use it if you don't need it? Same goes for old standards like SOAP. If it still works then no point in changing it. They all do pretty much the same thing anyway.

I've not even heard of trpc. goes and check. It's only 2 years old, that's why. What problem does it even solve? Types? We have OpenAPI for that.

From what I can see, new tech only become mainstream if it solves a problem. trpc may make things nicer to use, but since it doesn't solve a problem that's not already solved, it'll probably never get big enough to be mainstream.

Compare this to Typescript. Its first version was 2012. I started using it around 2019. 7 years after it was released. Was it doing something new? No. It's bringing static type checking to JS. In fact, I would argue that it makes the language feels more similar to existing languages like C# and Java.

Did it solve a problem? Definitely. Many people want static type checking. And here we are in a Typescript world.

Same goes with SSR/SSG, hydration, routing, etc. They solve a very particular problem. If you don't have that problem, no point in using it. Most websites still uses PHP and work just fine.

What you're observing is not the rise and fall of best practice and good engineering. All you're seeing is the hype cycle.

Best practice and good engineering in web dev is the same as it is in any other software field: the best stack is the one you know cold.

Unfortunately, there are many popular stacks, and all of them have something to say about all the others. And 80% of learning materials for any given stack aren't from official sources, but are instead blog posts and videos and tweets from tech influencers. When they parrot those same criticisms, it lends the air of a grassroots shifting of the whole community.

The fact of the matter is that despite the huge levels of hype flux, large, popular, stable apps are still being made with technology "boring" tech.

Despite SPAs, rails and Django apps are still built rendering server side templates and sprinkling jQuery where necessary. Despite GraphQL, REST APIs are still the state of the art for most APIs. Despite kubernetes and docker, many apps are still deployed to heroku or VPS providers.

It can be intimidating for newcomers because it can be difficult to separate hype from fact. My advice is to pick something, the more boring the better, and know it cold and ignore all claims of its death.

To address concerns about projects dying, that is pretty legitimate. Unfortunately webdevs deploy trusted code into a highly untrustworthy and antagonistic environment. New technologies do come to play and requires adapters and plugins to be written. I wouldn't worry about overall size of community as long as security issues are getting addressed.

I started off doing web development back in the late 90s, at first using Frontpage, then progressing to HTML. In the early 2000s, I was writing PHP and using MySQL.

I started doing web dev again around the Great Recession. Originally I was using CakePHP, but Microsoft offered my firm massive discounts on various licensing if we went all in on .NET.

So all new things were written in C# ASP.net, and I honestly can’t remember the specific framework.

In the last decade, I had some on and off web projects. I remember using Angular. Then React. There were various build tools, minification configs, CSS frameworks. The deployment scripts just copied a bundle of files and threw them to a specific location on a machine.

Anyway, the more interesting problems I solved in any kind of “web development” was around scaling… using CDNs for assets, using load balancers, having an entire fleet of servers, staggered deployments, canaries, metrics, dashboards, monitors and alarms, etc.

This is really what the complexity was. And a few times we dabbled in “write once, run anywhere” so we could share code on iOS and Android. It was really a function of, who are the staff engineers and do they prefer HTML, native stacks, or whatever framework,

Having said all that, I never understood the endless complexity in the raw web stack. Too many frameworks, too much tooling, and they’re optimizing for what exactly?

My take is that the barrier to entry in the web space was always low. You don’t need to really know data structures and algorithms to get started. And so with the influx of new people in the space, everyone has their tastes and preferences. But 90% of these use cases are not that different from the PHP and MySQL work I was doing. Except now there are entire industries around mastering whatever framework, youtube channels, etc etc. it’s a variety of microcultures.

Don't listen to all these people talking about various trendy frameworks, react, preact, typescript, hypescript and sh*tescript. Just keep it simple.

jest, mocha, jasmine, karma...why do I need to write unit tests, my code is freaking perfect \s

It's just pure cargo culting, most people don't know what they're talking about. You would be surprised how many people in front end don't even know that typescript has to be compiled into javascript.

Pretty much all of your complaints are self-inflicted by chasing bleeding edge tech. You don't have to do this.

> I've been burnt before using what was seen once as well-established and polished but when I tried it, it was in total decay (meteorJS).

You tried one older tech and gave up, while you're constantly re-upping on newer stuff without questioning that?

Also it sounds like you're only describing javascript. Javascript is kind of its own thing with its own issues/etc.. Try a different language. You'll always have to use JS for web development, but it doesn't have to be your whole world, either.

> the main reason is that Microsoft controls it - in contrast with say Go or Rust where it's controlled by a foundation

To my knowledge, and according to the website, Go is effectively entirely controlled by Google, not a foundation.

I don’t have anything to do with web development (and detest web applications and the idea of browsers as an application runtime) but use TypeScript elsewhere - any comparison to coffeescript seems misplaced. TS at this point is simply far too popular and widely used industry-wide to disappear, whereas coffeescript was always niche.

My advice is pick a framework you can get on with (and has mass market adoption, look at developer surveys) and stick with it. This likely means Vue/ react, you don't need to worry about all these other ones for a little while if it's causing you stress. This space is maturing, react has remained a solid choice since I started working with it many years ago now (yes it has warts, but so do most alternatives).

Regarding typescript, I think you'll need to get over your concerns if you want to remain in the web space. If you check any developer surveys it's only getting more popular. I doubht its going anywhere soon, and if it does the syntax will be likely be extremely similar, its a pretty natural way to add typing to JS.

Different areas of the dev world appeal to different people, naturally, but as a web dev since that became a thing (1995), I take a contrasting view.

The web is the most dynamic, most exciting space in software development right now and is likely to be so for the foreseeable future. It touches everyone, in every industry. Web interfaces and technologies are the most used languages on the planet, giving your work huge impact.

Have there been changes in this newest area of computing? Of course! Typescript isn't "controlled" by MS. It's just the future version of JS, available today. It's tremendously exciting for anyone who works with big JS codebases. Electron and other ways of building desktop apps out of the same tools is also a huge leap forward and let's web devs make stuff that's as beautiful and exciting as traditional desktop apps, all of which are incompatible with each other and have huge proprietary libraries.

Bare metal web components and Lit are able to replace outdated frameworks like Angular and React and this is a huge improvement, too. Finally, web sockets gives us an open two-way pipeline to communicate with multiple servers or clients without http.

Taken together, these elements represent an exciting time in web development when we can deliver apps that are beautiful, well written, and easy to maintain. The time for web dev has never been better! But it might not be a good match for you if you prefer working on other kinds of code.

My take on the endless cycle of change is that I love the enthusiasm and passion still being poured into the field but I must be diligent in evaluating what is being presented before believing it. Whenever a new framework or tool comes to my attention I try to ask myself what problem is this solving and do I actually have that problem? Most solutions usually come with trade offs and the times where I have made the best decisions are always when I understand what I am gaining at the expense of what it costs me. I try to remember that every new thing tries, rightfully so, to put its best foot forward and if I fail to do my due diligence in evaluating its offerings compared to my needs that I am doing myself a disservice.

I fully admit that I too sometimes find the noise of all the enthusiasm to be a bit taxing but I try to remind myself that I hear all the noise because I am excited about web dev. In the times where I am not tired of the noise I am seeking more and more of the latest and greatest. So I try to remind myself it’s ok to not pay attention to every single thing; not knowing about one particular thing will not prohibit me from making great things with what I do know.

It sounds like you are enjoying webdev so my advice is to do just that and remember that all the hype is just someone else’s passion for webdev too.

  I do like the ideas of webapps - that webapps can connect other services together or able to create 1 platform for "every" device.

Ah, The Platform.

The web development ecosystem is constantly evolving because The Platform is also constantly evolving.

I’m not saying that all of the churn is strictly necessary or what it’s not overwhelming, especially to beginners, and especially in hindsight.

The churn is in response to the fact that managing a development ecosystem for The Platform is a hard and impermanent problem to solve.

New solutions come about to address the complexity, but those have their own complexity that will eventually be addressed by another new solution. This can be frameworks and libraries, languages and tools, or alternative “platforms” altogether.

The reality is, most of the solutions available today are fine in their own respects. Plenty of real, production software is built on these technologies, even the “outdated” ones.

Try out some solutions. Pick one that clicks with you. Build your thing. You’ll learn valuable concepts. A lot of it will be transferable or analogous to other solutions you encounter in the future.

It’s easy: Pick tools you like a stick with them. There are no perfect tools/solutions out there. Only different flavours of compromises. So pick the flavour you like and master it. I picked React and Typescript. Perfect for me. I see no reason to pick anything else. So that gives me the long term stability needed to be productive.

You’re obviously still on a relatively shallow level of webdev craft.

Once you get deeper, you don’t have to “relearn” anything.

You just embrace the only constant thing which is the change.

And keep using the same basic ideas to deliver the product. Not caring about the labels under which the ideas are implemented today or whether it would be cosidered cool in 10 years.

I do webdev as a hobby. Making random cool projects and sharing them on Github for everyone to enjoy. I don't expect to get financially compensated for my efforts though. The reason I keep it as a hobby is that the thoughts of doing stuff for fun, and then /working/ on the same material at a job is excessive and means your whole life is swamped in coding, which is unhealthy.

There are many people who have 'went pro' and turned their hobby into a job, but I wouldn't be able to handle that. The thing about jobs is that you have to adhere to someone else's rules and schematics and work on things that don't excite you as a hobby would do. If possible, switch to doing code as a hobby and stop chasing jobs (which churn out code at breakneck speed and your code becomes vaporware within a month).

My advice is this: improve yourself/your knowledge to the point then you see all those libraries/frameworks have common parts implemented from different angles and all are very subjective because the authors had personal opinions. Then you'll realize you don't have to chase everything, just those things which really matter to you. I can recommend watching Alan Kay's videos on YouTube and understand what Smalltalk was, what were things like HyperCard etc. I really see web and web frameworks as -- poor in some aspects, like meta-circularity, or quite strong, for example in multimedia support -- reincarnation of those earlier ideas from 60s and 70s.

Front end development is particularly prone to the hype cycle. Other parts of the stack are a little more stable in their tooling. I personally believe this is because the front end ecosystem is comprised of more self taught and boot camp people. They’re super excited to do development and live on hype, whereas other areas are still more likely to be classically trained computer scientists and engineers that are less hype prone. This is of course a super over generalization and you can find tons of exceptions but if you look at the industry overall this is why I see it happening.

What was "total decay"?

Bunch of blog posts saying you should not use it?

SPA was not a mistake - it is just that people don't understand they could do static web page with interactivity sprinkled on it - it has use cases.

I work on web dev and use bunch of "x was a mistake" tools and somehow deliver good quality software.

Even if framework stops being actively developed it is plenty usable still. Unless there are of course serious security issues not fixable I could still stick with a framework.

honestly, it sounds like you need to take a vacation so these very common issues don’t feel overpowering.

“endless” is the problem, not that the technology moves forward.

you need to make space for yourself to exist outside of work, and carve out time to keep up with where the industry is going.

what you’re describing will lead to burnout because you’re always comparing or second guessing what you use and what you know to what someone/something else.

I cope by ignoring the hype and focusing on technical problems that I personally find interesting. There was a time when I followed the in-crowd and learned whatever framework happened to be flavor-of-the-month at the time, but I just don't care anymore. Yes, there are certain jobs that require you know the latest trendy tools, but there are a lot of jobs that don't.

Partly I think if you have experience in web dev, you learn to recognize which frameworks/technologies are worth pursuing and which are not.

It's also worth noting, some of it comes down to personal preference and purpose of the project.

If you're just dabbling, stick with something battle-tested, and if you aren't sure what that is, phone a friend. Or post on HN...

TypeScript is amazing though. I’d sell my soul to Microsoft for TypeScript lol.

Jokes aside, there are compile to JS languages that are really good and open source like ReScript.

Typescript is good, also waiting until more libraries/frameworks had real typescript support was a smart move on my part.

what is the endless cycles? the hype to learn things that obsolete tomorrow?

Drugs and alcohol.

IMO: the cycle largely doesn't matter and can be ignored... hear me out.

Been a web dev since the 90s, on and off, since before Javascript was invented. Twenty years later, it's still largely HTML and CSS, with JS globbed on. Here's the thing: the web, by its very nature, is a mountain of hacks on top of hacks on top of hacks, the result of having way too many cooks in the kitchen with no recipe. It just evolved organically, messily, clobbering different use cases together over time, all through mutating the HTML DOM -- little more than a glorified rich text doc.

Web dev is a craft wide as an ocean, shallow as a puddle. Whatever framework you use or don't use, at the end of the day you're just moving boxes/divs around and highlighting buttons and such. The complexity you see in the toolchain and frameworks is because JS and HTML are so barebones that you can't really do a lot of traditional software stuff with it easily, having to reinvent everything from routing to state management to basic network stuff... not to mention reinvent a backend. So each major tech company or small business or mid-sized SaaS provider sets out to solve some tiny part of it, either to make a name for themselves or to just make some internal workflow easier. The successful ones either see widespread adoption (React) or become part of the ECMAScript specs eventually (fetch, Web Components). And many companies try to invent their own version of an idealized backend, each having some 80% overlap with other major backends, but none that are 100% the best for all uses cases, so now you get to pick and choose from a hundred imperfect solutions rather than one best practice.

But so what? It largely doesn't matter.

Web dev has an incredibly low barrier to entry. Anybody can learn the basics in a few weeks, largely for free, and get a paying job with not much effort. AND it has a pretty low skill ceiling, unless you choose to specialize down a path of (say) DevOps or DB engineer or some backend stack, or start diving into one of the web-adjacent APIs (WASM, WebGL, Canvas). If you just focus on the frontend DOM, it doesn't really matter whether you use vanilla, jQuery, React, Angular, Vue, Svelte... it's all just HTML and JS in the end.

This field has incredible turnover: in frameworks, yes, but also in developers themselves, in managers, in companies, in fashions. As you pointed out, yesterday's "best practices" are today's "mistakes to avoid". Culturally, all of it is ephemeral and so very little of it is mission-critical. Maybe if you're working at an SaaS or IaaS company, you have to plan for 10+ years. But most online businesses just need a fancy catalog or marketing page or knowledge base or whatever, and fundamentally those are just several pages of UIs with a sprinkling of business logic and intertwined states to manage. The challenges are usually in thinking through the architecture and tradeoffs, not necessarily implementing any one framework or another.

At the end of the day, no matter which framework you use, they're still just making and mutating HTML. I can pretty much guarantee that whatever you write is going to be obsolete by the time it hits 1.0, because all the underlying packages and frameworks (and possibly languages and APIs) will have evolved by then. But that's OK. That just means your code can be as throwaway as the ecosystem itself... the standards aren't as high as in proper software engineering. You're just marking up a network-enabled Word document, and if something breaks, it's trivial to fix it and all your users will see the fix the next time they load your site. And two years from now, somebody will get paid to rewrite all of it anyway, using a technology you've never heard of.

While this can be frustrating, it doesn't have to be... if you just accept that the work is by nature ephemeral, that it's all throwaway code, you don't need to be attached to it anymore. Plan the best you can for a couple years out and the rest isn't up to you. No matter what you do, it's going to be redone very soon. You're not building cathedrals, just sand castles.

Alternatively, if you really hate this sort of UI-forward coding, you can also create your own systems of abstraction that architecturally separate business logic from UI code, with a purity of functions that can persist underlying API or framework changes. But then all you really end up doing is creating your own new framework. That's how the web got here in the first place. Everybody keeps trying to abstract away the limitations of the DOM and Javascript.

And if you don't like the new shiny, don't chase the new shiny. PHP and Java work largely the same as they did years ago, and still power large portions of the web. If you don't want to ever touch the constantly-mutating frontend, find a company big enough to let you specialize in backend API design and development so you never have to touch HTML, CSS, or JS. If you like the somewhat shiny, just not the bleeding edge, you can totally do that. Just pick React and roll with it... it's already considered old and lame (meaning mature) by this point, so if you start out knowing you're choosing older tech, it won't matter as much that it's still old 2 years later. For the backend stack, there are also very mature technologies that have relatively stabilized. Who cares what the new kids on the block are doing? If you're not working at multi-million dollar company who own their own data centers and resell their architectures to other companies, nobody is really going to care all that much about your stack, because it's unlikely to be perfect to begin with and it's not going to survive turnover very long. Again, it's all ephemeral, and that's OK. Don't let the perfect be the enemy of the good.

Learning to love the web is learning to love short-lived mediocrity. You're just speed-dating, not marrying a framework. It's all going to be thrown away in a couple years, and nobody will remember or care why you did what you did. That's OK. You won't remember or care either. Just move on then and do something new somewhere else... you're getting paid along the way, and hopefully enjoying yourself enough. Don't worry about the future so much. Nobody else in the web ecosystem does, lol.