Why is Node.js hated so much?

Probably the worst thing is that the standard library with Node Javascript is tiny. Therefore, you have to pull in a pile of NPM packages to do pretty much anything. The package ecosystem is rather messy for the same reason - there's a mountain of tiny packages doing a few little things because somebody needed to do just a few things and didn't want to pull in some massive library that does a ton of stuff including the thing they need to do. Which then leads to a lot of bigger and more useful packages having huge dependency trees of tons of little packages, all at poorly-managed versions that usually can't be shared with any other big packages. So a program that needs, say, 3 major packages to do something useful might end up with thousands of dependencies taking up hundreds of megabytes, often with 3+ copies of the same package at different versions.

For example, I have a little webapp that I built with create-react-app with typescript and redux. Very convenient overall admittedly. It's not very big, maybe 1k lines of code total, and 3 fairly minor packages added to do various things. The node_modules folder has over a thousand items in it, and takes up 350MB. The yarn.lock file alone is half a megabyte. Ahem, what the hell? At least the built artifacts are pretty small.

This might be seen as just a problem with create-react-app. But in my experience so far, pretty much everything in the Node world does this. Seriously, has anyone managed to do something useful in the Node world without ending up with a thousand packages?

JavaScript is a language whose flaws are well understood by experienced developers, and those flaws are massive.

I also don't particularly care for "async everything" by default. It makes your program more difficult to reason about. Rather than dealing with concurrency in a subset of your application, you now have to worry about it _everywhere_. There are only a few classes of software where the async-everything approach even makes sense.

Throw in the fact that the ecosystem is an absolute dumpster fire and you have more than enough justification.

Node is hated because programmers are highly opinionated (not in a negative way). Everything with huge usage gets hate, because everything has flaws and trade offs. People get forced to use it at work, sometimes to solve the wrong kinds of problems for it's strengths, which amplifies the dislike. It's the nature of the beast.

Here's the thing. JS does not suck. Node does not suck. They exist and are widely used precisely because they do not suck and deliver many advantages that are preferred by many developers over alternatives.

I hate Python and could go on all day about what's wrong with it, but it doesn't suck. I use it when it is appropriate for the task at hand, but find it is rarely the best language for the job - given what I know and what I prefer.

Most people that hate a language also avoid it and, therefore, tend to not have made their peace with its shortcomings, so don't have an honest reckoning.

It is unfair to completely disparage a language until you have fully figured out how to understand and work with it, warts and all. Frankly, until then, you aren't yet informed enough to make a summary judgement. You are just cherry-picking your dislikes.

I have rarely heard a criticism that did anything but highlight the critic's lack of knowledge. For example, there is a common criticism about the lack of a standard library. Well, that is how the ES or Node ecosystems are structured. It is not a flaw - it is just a different approach. If you work intelligently within that paradigm, it is actually quite nice. If you hold onto your expectation that a standard library is a part of any respectable ecosystem, you're going to be perpetually dissatisfied with ES/Node. It may not be what you like or expect, but it is not inherently wrong or lacking.

Parenthetically, anyone who makes the standard library complaint about Node just doesn't know Node. It has a very complete set of functionality natively, for its purpose. It is not going to offer much in the way of math operations, sorting algorithms, etc. That is not its purpose. If you want those things, you can add them.

If you think that a given dependency is too big, too small, incomplete, or poorly managed, write your own, and publish it like many have done.

But be warned - if it gets popular, there will be no end of complaints about what's wrong with your library because ... well ... it is actually developers who suck. We have opinions and are quick to convince ourselves that those opinions are fact and anyone who disagrees is not as smart as we are.

Something that I don't see mentioned here, but which I believe drives a lot of the controversy around Node, is that it takes an extremely unopinionated approach to web development.

That is, Node.js out of the box is really just a javascript runtime. You need a package to serve html, you need to decide on an application architecture and organizational structure, you need to choose an ORM. You need to make a lot of decisions that other web frameworks like Django or Rails just make for you when you build a project.

The lack of opinionated defaults has some benefits: - It gives you a ton of flexibility - It makes it easy to learn the framework, since there's no magic. - It forces the team to really understand what the application does from first principles, again since there is no magic.

The other side of this coin is that flexibility often leads to architectural chaos, and working with Node can feel very slow, since you're constantly reinventing the wheel.

The reality is that 80% of the things I'm building basically just need some variety of MVC with a reliable and predictable way to connect to a SQL database, and Node doesn't feel like the right tool for that job.

Can’t remember where I first heard this but I think it applies here: There are two kinds of programming languages. Those people complain about and those no one uses.

EDIT: To add a more constructive comment: Don’t worry too much when people hate on a given language and don’t try to make a decision based on what tool or language people are complaining about. Every tool has its usefulness and its drawbacks.

Because of this:

https://i.redd.it/h7nt4keyd7oy.jpg

I remember back in the late 2000's/early 2010s, there was a blogger, I think at google, who claimed that "the next programming language has already been chosen for you". In retrospect, he was clearly talking about javascript, which got a tremendous push from the big tech players despite all its obvious problems. Now we are stuck with a mess of code written in an ugly language.

Why the big guys picked javascript, I don't know. Maybe to ensure that everyone was so bogged down in dependencies, language incompatibilities and callback hell that no competitors would arise?

EDIT: It was Steve Yeggie, back in 2007: https://steve-yegge.blogspot.com/2007/02/next-big-language.h...

For me, it's less an equation of active hate. I can actually see why some people like it, and I wouldn't want to get in anyone's way on that.

That said, I have found that the .NET ecosystem is an agreeable way to build the kind of software I need to build. I don't think my product would be infeasible in a Node.JS ecosystem, but it would certainly be more painful for reasons that are specific to our problem domain.

If I had to take a shot across the proverbial HN language war deck, I would say that dependency management is the biggest reason I would prefer to avoid Node.JS on future projects. I have a very complex .NET code base which uses 3rd party dependencies you can count on one hand. Our customers really enjoy that kind of thing.

It’s hated by people who have either never bothered with it and are on the JS hate train, or it’s hated by people who had to deal with poorly executed code. If you know the use case fits, then it’s great and will help you scale fast at minimal cost. However that takes a bit of experience to understand/implement.

It has some flaws sure, but unless you’re going out of your way to use poor practices or using node for a task it isn’t great for, that’s kinda on you right?

Used node for many things, including services currently in use by many millions of users. It’s just a tool in the toolbox, so use it like one where it makes sense.

My guess is because:

- lots of people don't like Javascript

- lots of people don't like V8

- the guy who made Node.js (Ryan Dahl) doesn't like it either

- programmers think anything without thread support is a toy

I like Node.js, Javascript, and Ryan Dahl, and have no strong opinions on V8.

Being heavily coupled to the front-end. There's a perceived attitude that many Node devs are just front-end devs with enough back-end knowledge to be dangerous. With this is the overloading of the term "full stack".

The early perceived coupling with MongoDB didn't help.

I used to hate it, but async/await, typescrypt and ts-node makes it more acceptable nowadays.

I don’t think it’s Node that people don’t like. It’s more the ecosystem and developers around it. An example would be people focusing more on branding and landing pages.

I don't hate node, I just realized that on the server-side, by the time I added enough modules to make something work I could get better performance from a Jakarta EE application server and write far less code.

Go's standard library comes with a lot of the same batteries built in and while I write more code in Go, the compiled binary is small (good for container management) and I use less dependencies.

So that last sentence is the key. When I was writing a lot of Java, I learned to curate my dependency graph carefully. When writing in Go, I've become even more careful to only use widely-adopted packages though I'm a bit more lenient with test-only package.

I've predominately stopped using Node.js because it's dependency graph is simply unmanageable. Node.js itself provides a facade of multiprocessing as well as other niceties you'd expect to find on the server-side but to do anything substantial you either need to code it yourself or you adopt a huge dependency tree. Downstream security vulnerabilities and bugs mean you're continuously updating versions and it's not always pretty.

Now that I've adopted the write a bit more code and use fewer dependencies mentality, perhaps I should try another project in Node.js. I have to admit that Typescript (and even some of the EMCA improvements) also make it more attractive.

“There are only two kinds of languages: the ones people complain about and the ones nobody uses.” —— Bjarne Stroustrup

Full Stack. Now, that's a dirty composite in some corners and rarely entirely true-- but in some cases... backend (Node) and front-end (let's say React) are not handled by two developers, but one. They might also sing the theme tune. That flexibility regardless of the fat wad of packages, is both profitable (in the short term) and valuable in the long term as a proof of concept. Who develops something and says "that's done, finished, everlasting"? It's useful to have a combined ecosystem in many cases, accessible and friendly to a single, dare I say it, "Full Stack" developer. If it needs to be made better, if it needs refactoring, everything is on the table until it doesn't make sense. If the product works great... if it needs to move away from node, fine. If you build a house that's worth looking at, nobody's thinking about the bricks, but that doesn't mean things should stay as they are.

It's not.

I work with a range of languages - go, rust, python, ruby, and yes even JavaScript. In my 15 years as an engineer most of the engineering teams tasked with a node project I've worked with enjoyed it quite a bit. Those who didn't struggled because they were still learning the more functional patterns used in the node community, and it required some relearning given the languages they came from. In my experience 99% of the time those who express a hatred for node have never programed with it, or lack experience. Now given that there are shortcomings like any tool or language. But hating it - doesn't make any sense to me unless your ignorant of it. It's a fantastic programming environment. By the way if anyone thinks that JavaScript is on the same level as PHP I invite you to visit PHP sadness.

For a front end language designed in 2 weeks it is quite good. That we are stuck with it is kinda sad but its good enough.

If you design a tool (or DSL) you must tailor it to the problem it needs to solve. It must not be overly generic while still covering the entire scope. This is extremely hard and it usually takes a few versions for a language to get it right.

Then we take the DSL and implement it in an entirely different situation(????) Look, I can use my wrench to hammer in nails!

What to say? The nails are indeed going in. Massive structures are erected. They are structurally sound but it just doesn't look professional to people who are used to hammers. I'm going to be using a hammer until end of time. I tried holding the wrench over the nail but I just couldn't bring myself to hit it.

(with hammer I mean PHP)

It was like mold that suddenly grew everywhere. Monopoly of JS in browsers translated into a big share of server-side pie too. People had all the options and they chose JS still, not a situation to be happy about if you ask me.

It is hated so much because it is used so much. If it was a niche or obscure platform then no-one would have cared.

I would be very appreciated if somebody could answer me :)

First of all: 1) I'm a self-taught developer 2) I spend last year building my app on MERN stack

The problem with JavaScript technologies is that you have to add many dependencies into your project. Each module / library / framework has their own documentation which is time consuming if you are self-taught to go through it

The question really is: - Is .NET or any other framework so called "battery included" ? or I also need to add hundreds of dependencies i.e. authentication -> password hashing, jsonwebtokens etc.. - As .NET or any other framework requires more code vs Node.js -> does it pay off later on during refactoring? Means is it more productive vs any JS framework?

I'm really considering to spend next year learning C# with .NET because being solo dev it's really time consuming constantly monitor what did change and what needs to be refactored. JS stack doesn't help with maintaining the project in a long run (or I have limitted knowledge) it is really time consuming stack tbh

I agree that creating a simple CRUD app for web course it is easy but if you need to do something more advanced...

Should I start learning C# ? or .NET also require thousands of depedencies i.e. file upload (multer docs!!! Man I know them almost by heart now...)

I've only run into one person IRL who smacktalks Javascript. Then later I edited his Ruby script. And I was like "uhh... this could all be done in nodejs, or python, it really doesnt matter". He said javascript is a toy language.

Whereas... I had worked with php, python, R, and once I got to NodeJS I fell in love with it. Then picked up ReactJS

And man, so glad I went this route. I never have to apply to jobs again, given the hunger of recruiters for full stack JS devs

Many people here mentioned the dependency hell in Node. Why dont the core Node developers work on improving their standard library?

A tiny project in javascript/nodejs land has a bonkers node_modules folder full of files upon files upon files. The whole ecosystem is rotten, top to bottom. I personally know many devs who have hit the eject button and now just code in Elixir. They opted out of the lunacy that is nodejs/javascript.

I think about Node.js the same way that I think about the set of wrenches I have downstairs. It is a tool that I use for specific tasks. It lets me do some things in JS that I wouldn't normally and it does it efficiently enough that I don't need to look for other tools.

I don't use it for full applications so I don't have some of the same issues that @ufmace mentions (ouch!) and those are clearly a problem.

I suspect that a lot of the hate comes from people that would like a better Node.js so they could use it but resent that it isn't available

Why do you think it is hated? Seems to be one of the most popular backends right now. Personally, I dislike the lack of convention and immature library ecosystem.

On the question of "is it hated", Stackoverflow publishes a survey every year on interesting questions like this. It doesn't get a lot of attention here for whatever reason.

https://insights.stackoverflow.com/survey/2021#most-loved-dr...

I have no personal issues with JS/Node.js except that when I was learning it there were so many different ways to create objects that it took me a while to sort out how I wanted to do it and what all the trade offs are.

I don’t like it because I don’t enjoy JS. Node itself seems great, it just needs a large standard library and mandate some form of Typescript. Even if it had those changes I’d stick to C# or take a look at Elixir.

Because it doesn't require __init__.py in every directory?

Node and JavaScript are extremely popular (used by a ton of people).

Being popular means you get a lot of criticism. Same happens to java, PHP, and any other popular language.

To me it's the async function coloring mess of js which made node unattractive. ( together with the import require mjs split )

It's liked and used more than it's hated.

I think this is self evident but maybe someone else will care to list some usage statistics.

My experience installing several tools that are built on nodejs has led me to the conclusion that I will simply not use something if it's made with nodejs. I'm not installing 127 dependencies just to get some tiny CLI tool to run. Give me any Linux tool written in Rust, Go, C, C++, Python, it always goes well and without fuss. But nodejs and ruby based software has given me nothing but headaches.

Node has a low barrier to entry(JS), and that shows in the quality of the work. If anyone remembers QBasic, it was hated for the same reasons. It's great to grasp core concepts with, but inappropriate to build something like an ERP system. It's a toy, although a powerful one.

I think it is liked quite a bit, but if I had to point out; 1) the ecosystem; it is rotten 2) people think JS is the old JS which had callback hell and other misery: there still is misery but less and with Typescript it is ok. But I think not as many hate it vs like it.

I don't think it's hated. Tons of node lovers out there :)

Node.js hated by developers cause of JavaScript, the most hated language. It's simple.

Considering its popularity, vast ecosystem, and widespread use, you can't just state that it's hated so much - that is just your impression based on few very noisy people.

I think many people feel threatened by the success and the pace of the Node.js ecosystem.

Most arguments, even in this thread already, are just wrong. Obviously they have never had any experience with the Node.js ecosystem and another.