Hacker News Reader

Comment by bambax | Hacker News Reader

The real question is, do we actually need "frameworks"? Pure JS works pretty well, and no JS at all even better.

I recently worked on an SAP project where there was a whole Java layer in front of SAP, and then a huge Angular app on top of it all; but since the point of the application was to manage b2b sales of physical things and it mattered very much whether those things were in stock, almost every screen did a full request to the SAP layer. The need for a thick "rich" client was unclear, and PHP would probably have worked much better.

Hype aside, it seems big organizations are using frameworks as a mean to ensure uniform coding practices and make developers more easily replaceable; but surely there are better ways to achieve that.

View on HN

Not every page or app needs framework. But building complex app without one would be very hard and time consuming, and your team would need to come up with ways to solve problems like architecture, code structure, routing, data management, state management, etc. So you would basically reinvent all the wheels on your own cost, and you will have a non standard solution, that would not be compatible with libraries out there (for example UI components) and neither with new devs. Before Angular and React came I was building apps with plain JS with jQuery (not a framework, just a lib) and I would never go back there.

I agree. In a recent small project, I ran an experiment: first, I built the app in React, then in Vue, and finally in vanilla JS. In the end, I stuck with the vanilla JS version because it was significantly smaller, easier to deploy, and much simpler to maintain long-term.

I worked at a startup where one of the original devs had “strong opinions” on JavaScript frameworks. “It’s all bloat!!! We don’t need that crap”. So consequently all the new engineers had to learn this dude’s codebase, which turned into to be… A framework! Only instead of a documented one that had plenty of support it was an unholy mess that required extra time to build all the stuff missing from the it’s-not-a-bloated-framework-but-pure-JavaScript-framework.

Guess what happened the day after the dude left the company? All the engineers immediately started to replace the unholy mess of “totally not a framework” framework with an actual one.

Guess what happened to development productivity and product quality? They went up dramatically.

As someone who's worked on web apps with and without frameworks, yes, we need frameworks, especially if it's a large one or if there's a team of more than a few people involved.

The good ones these days like Vue or especially Svelte are barely any different to how you'd do things the "vanilla" way except they provide some sane QoL features like components (anyone who says web components are the answer has very obviously never used web components) and sane data flow management to and from said components.

I mean, more power to you if you want to handle complex states without the features a lib like Vue or Svelte provide you, but in my experience you eventually end up with a homecooked framework anyways, even for apps that aren't that complex. And at that point you're just doing React or Angular or Vue, but worse in every conceivable way. Yay for going at it vanilla, I guess?

> I mean, more power to you if you want to handle complex states without the features a lib like Vue or Svelte provide you, but in my experience you eventually end up with a homecooked framework anyways

If state needs to be managed client-side (which is not always the case), then yes, a library is helpful. But a "framework" provides much more than state management, and those other things are usually dispensable, IMHO.

> but worse in every conceivable way

I always had an issue with that sentence (and I heard it a lot). Why would experienced software developers always come with a solution worse in "every conceivable way" when implementing logic answering a problem they're having, which would have the huge advantage of being tailored for their own needs?

I'm more of a library developer than an application one but I've seen that many JS webdevs have an aversion toward trying things themselves - instead always going for the most huge/"starred" dependency when they can. I'm not sure the impact of this philosophy is always better for a project's health than the total opposite where you would just re-invent your own wheel.

I do have seen multiple attempts at doing a specific homemade architecture that worked out well for some applications with very specific needs even 10 years later (For example I'm thinking about a 500k+ LOC JS webapp - not intended to be accessed on a desktop browser, but that's not the only successful long-lived JS project I know with their own archi). And I guess a lot of webapps do have their own specific needs where the "default framework" solution leads to some inefficiencies or hard-to-maintain / understand mess.

> The real question is, do we actually need "frameworks"?

Yes. The advantage of having a common API across thousands of web apps shouldn't be a point of discussion.

Pure JS is that interface... you're arguing for multiple unnecessary abstraction layers piled on top of each other.

More abstraction != easier to use.

Spot on. HTML, JS, and CSS deliver a clean separation of concerns—a perfect blank slate for killer products. You just need a few key pieces to tie it all together: templating with loops for repeating HTML chunks and a way to stitch in headers, footers, or sidebars. For apps, a routing system is a must. And HMR to supercharge your dev workflow. That’s Nue in a nutshell.

> HTML, JS, and CSS deliver a clean separation of concerns

There's nothing clean about this separation, and concerns are never as neatly separated as people pretend they are.

> For apps,

For apps you need actual app-like things where your separation of concerns looks like the right image here: https://x.com/simonswiss/status/1664736786671869952

>> HTML, JS, and CSS deliver a clean separation of concerns

> There's nothing clean about this separation, and concerns are never as neatly separated as people pretend they are.

It's very clean and something repeated by almost every UI framework and document system. The separation is between structure, style, and interactivity. Most web apps actually fits the document models where you have content pages and forms. But people wants to bring desktop and game UI patterns into that. And make it a mess.

> It's very clean

It's not

> something repeated by almost every UI framework and document system.

That is, hardly any UI framework separates these things. From Windows APIs to SwiftUI there's rarely a system which tries to separate these concepts. Because however hard you pretend they are separated, they never are.

> Most web apps actually fits the document models where you have content pages and forms.

Even in a document your styles are linked to the structure of your document.

> Because however hard you pretend they are separated, they never are.

That would hold true for whatever systems. The pretention is just for making it easier to do the job without extraneous effort. Cascading is a nice pattern for applying properties in the case of a document. JS was originally intended for scripting (not for full-blown application) and the DOM API works fine for that. Without that, we would have to put everything in HTML or have something like Flash.

> That would hold true for whatever systems.

Remember how you started with how every UI system and framework was somehow this separtaion of style and presentation and structure and interactivity?

And now it's "they are never separated, and this holds true for whatever systems"

> The pretention is just for making it easier to do the job without extraneous effort.

In reality there's a lot of extraneous effort especially when systems become more complex. BEM was invented not because CSS was great and amazing at reducing effort, but because it was adding a great amount of effort for a very large number of designs.

CSS Scoping was finally, thankfully, added not because cascading nature of CSS reduces a lot of effort.

The rest of your comment has nothing to do with what I said.

> And now it's "they are never separated, and this holds true for whatever systems"

What I described as separation is a a decomposition into modules which are linked together through a contract. CSS has cascading and selectors, while JS has the DOM API. Otherwise, it would still be attributes on tags.

BEM is just a development technique, not a technical requirement or capability. Without cascading, we would probably have components and inheritance.

> Remember how you started with how every UI system and framework was somehow this separtaion of style and presentation and structure and interactivity?

On Android and iOS, you have XML for layout. QT and GTK have support for CSS like styles. I remember at least one of the have supported XML for layout definition. They're not required, but they make it easier to build the UI as it almost always have a tree structure.

> What I described as separation is a a decomposition into modules which are linked together through a contract.

wat

> Without cascading, we would probably have components and inheritance.

indeed. That is why I wrote what I wrote about BEM and CSS Scoping

> They're not required, but they make it easier to build the UI as it almost always have a tree structure.

Those systems have support, but there's rarely, if ever, a true separation of styling and structure. There's a reason for that, illustrated here: https://x.com/simonswiss/status/1664736786671869952

The separation between CSS and HTML is a good idea in a very theoretical abstract academic sense. It never ever worked in practice.

Your comment shows that you don‘t have a lot of experience in that matter. „Pure JS“ (there is no such thing) has perhaps the tiniest standard library of anything out there. The rest is browser vendor code, of which a lot depends on browsers and versions. Hell, they didn‘t even get date parsing right.

"Pure" JS exists as a concept, not a project.

Having a tiny standard library is also a good thing, not a bad one... I'm not saying its an ideal API but in general, smaller==better (within reason).

The advantage of having a common API across thousands of web apps shouldn't be a point of discussion.

We have one. It's called "the browser". The discussion is whether or not we need a higher level API than that. If we do, maybe that should also be a part of the browser's API.

It would be easier if "the browser" is just one target.

As it is, there multiple browsers supporting different levels of features.

That's the whole reason why frameworks are made in the first place dating back to jQuery.

The days of IE6 which justified jQuery are long gone.

All browsers that matter now support a solid common set of features which should be sufficient for the vast majority of cases.

You still can‘t style select elements in anything but brand new alpha chrome. It‘s been 20 years since that feature was requested.

> All browsers that matter now support a solid common set of features which should be sufficient for the vast majority of cases.

All it takes is one of those non majority use cases and you're going to need some kind of dependency to get things consistent

Frameworks like Vue 3 don't actually work on older browsers since it requires ES2016 support in the browsers.. that means IE 11 and older browsers are out. With Svelte you need Microsoft Edge (IE 11 is not supported). Also, it requires Firefox 74 (released in 2020) or newer Firefox versions.

With React, you can make it work with older browsers using Polyfill etc.

> The discussion is whether or not we need a higher level API than that.

Try using DOM APIs to build anything remotely complex or interactive. There's a reason everyone who only uses browser APIs ends up just dumping strings into the DOM via innerHtml.

> Try using DOM APIs to build anything remotely complex or interactive.

I think the core question is: Are we building something complex or interactive. I don't see the need for React or other frameworks unless you're storing a lot of mutable states client-side. But more often than not, all I see is replicating the database through API endpoints.

Any user facing website that is not a portfolio site is interactive. The days where the web is display-only are long past.

„The browser“ doesn‘t exist. So no, we don‘t have one.

Reply on news.ycombinator.com