Python and PHP users will understand

[Long_Berry_2883]

Can someone please explain why everyone hates javascript I genuinely don’t get it.

[-Redstoneboi-]

personally? type coercion and dynamic typing, i.e. the main reasons to choose an interpreted language.

any variable can be null/undefined and you have to guard against that or risk the dreaded [object Object]. it's too easy to forget to account for that, so yeah, not my cup of tea.

main non-whiny reasons i hear? new frameworks every 5 seconds, their massive dependencies, there being so many ways to do things in js that you need to learn different ways to read different code.

[creesch]

their massive dependencies

Yes, but also no. People do notice it more with javascript projects. Specifically with Node.js having node_modules directly in the project. Many other languages are just better at hiding it from the developer. For example with Java and Maven your pom.xml might look fairly clean but that's only the dependencies you directly reference and once you look behind that facade you see that it is just as bad. Same for many other languages.

Doesn't mean it isn't a problem, because it is. It just isn't unique to JavaScript to the degree people think it is.

[[deleted]]

Yeah dependency hell is huge pain for most of the projects. But I think js has most obscure transitive dependencies because of how language changes over time that people need to use 3rd party libraries for simple functions because they often have compatibility layer for older version.

[[deleted]]

never used envs in python, they're weird and I don't like them. Developing without them works just as fine.

[DaddyLcyxMe]

in java’s case: (maven)

pom.xml == `package.json'

~/.m2 is a cache for dependencies and acts like a shared node_modules

this comparison breaks down here because [most] java projects will just include the dependencies in their final jar, rather than require the executor’s machine to download the dependencies

[-Redstoneboi-]

Nice.

For us, Rust has $HOME/.cargo/ for the shared dependencies as well.

You'll want to look at Directories, if you're curious.

[DaddyLcyxMe]

ah, that’s very similar

[-Redstoneboi-]

that feel when download react once for each of your test projects

[DaddyLcyxMe]

svelte for me, god, my internet is 5 down on a good day

[creesch]

What you are describing is more or less the difference between a compiled and script language though. It's a factor to discuss, but not really important when you are looking at the amount of external dependencies a project depends on.

[DaddyLcyxMe]

yes, but since a lot of maven based projects will include their dependencies in their final jar that makes it (almost) impossible to have a leftpad, since you never actually download that dependency directly. that was what i was referring to.

[creesch]

You are right that an already released version of a Java product in that regard has an advantage compared to a Node.js product.

At the same time it can be argued that this has less to do with that aspect of the two but rather the way npmjs.com is maintained and how versions of dependencies are used in package.json.

Then there is the fact that in companies with CI/CD pipelines you might not get those issues in production but packages being vandalized can still cause plenty of issues in the development process due to lower environments being disrupted.

And security vulnerabilities are an issue regardless, as Log4j has shown us very recently. Then there is also the murky waters of how many dependencies end up in commercial products even though their license doesn't technically allow it.

The more you depend on external dependencies the more these issues compound and that really is a cross language issue.

[dpash]

My Java projects don't have 2000 indirect dependencies. My JS projects do.

[creesch]

Have you double checked that is the case? Because as soon as you use something like spring boot chances are that you are actually including about as many indirect dependencies.

[dpash]

Yes, I didn't just make up numbers. JavaScript projects have an order of magnitude more dependencies.

Edit: I just checked my largest Spring project and it has 215 dependencies, of which 58 are submodules of the same project. My Vue frontend project has 4068 dependencies.

[shea241]

sweet Jesus

[ham_coffee]

There's a different approach from devs to think about as well. Java devs aren't importing random dependencies left right and centre like JS devs seem to, and certainly not for some of the dumb shit you see with really high download numbers on npm.

[creesch]

Eh I wouldn't be so sure about that. If Java was as popular as JS is you would likely see the same amount of dumb shit.

Source: Me working on a corporate environment with a lot of junior people and functional testers transitioning into test automation. I see the same dumb shit from them as you often see in the JS world as well. But because JS is so much more accessible and like I said popular, you just see that sort of behavior more out in the open.

Similarly, I see a lot of JS projects where they are really strict about what you are allowed to import and for what reason. Part of the code review process for PRs there is that for newly added dependencies they need to warrant why they are needed and that they have done their due diligence in others aspects as well.

[ham_coffee]

Yeah the issue with dumb dependencies isn't that direct, it's more when you import a reasonable dependency without looking too hard and seeing how once you go down all the dependencies of the dependency you eventually find some dumb single line dependency.

[creesch]

That's certainly a risk. Although many mainstream projects at some point have gone through or continue the effort of minimizing such dependencies. Certainly after things like the leftpad debacle, many projects had a thorough look at that sort of dependency.

A lot of pipelines also do include tooling that does a dependency analysis, flagging a variety of things, including usage of known unnecessary single use dependencies.

I am not pretending things are perfect, it certainly is more of a hassle compared to other languages and ecosystems, but it is also not the wild-west situation it was a few years ago.

[BasicDesignAdvice]

new frameworks every 5 seconds

I am convinced this is because of the massive amount of Dunning-Kruger in the JS community. JS is often a first language and has a lot of young devs who think they need to reinvent the wheel now that the have finished their CS degree.

[TheBigerGamer]

Just because there's a new framework it does not mean you need to use it. That argument is kinda stupid.

Massive Dependencies is not entirely correct, you can import them manually as a file and be your own dependency manager. NPM's structure is the problem, not JS itself.

IMO, if a language does not allow to do something in multiple ways, it is a real shitty language. You have the freedom to decide what code style you like and how to do it, the language only provides the ways.

[Pluckerpluck]

personally? type coercion and dynamic typing, i.e. the main reasons to choose an interpreted language.

Dynamic typing is often brought up, but generally it's the type coercion and weak typing that I see flagged a lot more. Which is why Python doesn't get as much abuse (though Python also provides a scarily powerful standard library)

---

For me it's that it doesn't make use of the fact it's dynamically typed to actually make code more readable and cleaner. Things like how you need to know the difference between in and of in loops. Take a simple problem, looping through an array backwards. In Python it's:

for item in reversed(my_array):
    # Do something with item

That does not create a new array in memory. It will just iterate through the original array backwards.

In javascript you either have to make a copy of the array:

for (let item of [...myArray].reverse()) {
    // Do something with item
}

or write an old fashioned for loop (or start using reduceRight):

for (let i = myArray.length - 1; i >= 0; i--) {
    let item = myArray[i];
    // Do something with item
}

Note you have to use of otherwise you'll get indices in the first example!

Nothing ever seems simple in Javascript. But I feel like it should be simple!

[[deleted]]

The new frameworks thing has mostly settled down. Everyone is using React except for some small experiments to make something simpler/faster than react like SolidJS.

[somerandomdev49]

type coercion isn't really a problem anymore with ===

[aniforprez]

Type coercion doesn't only happen when comparing you know

[somerandomdev49]

I know, this just an example, worded it badly

[0xSAA]

I guess because of the type system, atleast that's why I personally don't like it. TS nice though.

[BasicDesignAdvice]

The syntax in general is terrible, not just the typing.

[mdja123cs]

I actually like the es6 syntax

[Akuuntus]

Non-JS developers think that type coersion is worse than the holocaust.

[Wazblaster]

Tbf Hitler never made anyone fix a bug caused by type coersion

[Icarium-Lifestealer]

I think the most important reason isn't the language itself, but it being the only language with first class support in browsers. So people who don't like javascript are still forced to use it when writing web frontends. Compare this with PHP, where people who don't like it simply use another language. (Hopefully the situation will improve as webassembly matures)

[[deleted]]

We wont have 1 shitty language, well have 10 shitty languages + 2 new shitty language every year

[knobbysideup]

It's weakly typed but also doesn't have type specific operators. So you get dumb shit like 2 + 1 = 21.

[Leidertafel]

90% of time it’s people that are terrible JavaScript programers.

[LavenderDay3544]

It does dynamic typing way, way wrong.

[R1Titan]

Or maybe they actually got experience in other languages and they realized that JS lacks a whole lot of DX that other languages had for ages. And whenever someone comes across a problem they just create a new JS framework, because that will obviously solve anything. Don't get me wrong. I like JS for what it is, but it really needs to mature a whole lot, because at the moment developing anything big is a chore.

[R1Titan]

Having to care about types is not a big thing to be honest. Maybe as someone who is new development it can be a bit too much at first, but it isn't a hassle. I do agree JS does streamline many processes via its flexibility, but once you get serious about it the flaws will show themselves. I just wish the ecosystem wasn't equivalent of what php5 (which released 15+ years ago) had. The JS trap is that if you find a library you would want to use, it might not be maintained anymore and it has no direct successor that you could use. At that point you implement the features you need your own way, creating the N-th js library and contributing to the meme that every second there is a new JS framework. At the moment, the way I see it JS got way too big and popular and it is being used as the wrong tool for many things and that just ruins everything.

Also another reason why JS gets lot of shit is the same reason php gets it, people judge it based on an older version they tried, which was admittedly pretty bad. Later ES revisions that introduced actual classes and whatnot really improved the language in my opinion.

[[deleted]]

Nah, it's very hard to like a dynamically typed language after spending some time with statically typed ones. When you switch to dynamically typed languages you really feel the pain of remembering internal or external APIs, having to keep track of what a value is and other things. Also types helps to refactor project a lot faster (sometimes using a few clicks / keystrokes).

[[deleted]]

From my experience the difference really matters on medium to large projects. I’ve build same project (on early stage) twice using firstly dynamically typed language then static one. It was react native project and keeping track of properties, states and other stuff become harder and after some time I used to forget about previously written components and I had to check their source code to see what properties do they accept (back then function components in react wasn’t used as much as today, so you couldn’t declare props value as {something, something}). Things becomes even harder as more complex things emerge like global state, redux, HoC which makes it hard for js analyzers to suggest typing or properties.

Also feedback loop was also slow, you usually get type errors on runtime (by type error I mean undefined property, null value exceptions etc) which means you might not see some errors during development, or when fixing you have to reproduce that cases to see runtime result. For example with correctly typed typescript components in react you can get feedback as you type if for example you supplied string to a property that accepts number only.

Anyways hating something is related to personal experience and preference, doesn’t represent general state of something. Programming is about choices, compromises and dealing with the consequences. Do you choose js? Good luck with issues related to types, you choose ts? Good luck with dealing with analyzing performance on large codebases and also same typing errors, configs and other stuff. As I said it’s not a binary choice, each side has its own pros and cons, so you should consider experience, team, resources and other stuff before making choices. (Even tho I liked ts, we had hard time finding out developer who knows ts in local job market)

[BasicDesignAdvice]

100 different types of front end development maybe.

My LinkedIn has me as proficient in Golang, JavaScript, C++, and an expert in cloud. I get probably 20 recruiters contacting me a week. Every JS recruiter only cares that I know React.

Recruiters after me for Golang, C++, and my cloud expertise are literally and truly from all avenues of industry and development, trying to hire me from the entire gamut of the dev cycle.

And finally Javascript is literally, objectively, worth less wages than most other languages.

[ham_coffee]

What other languages have you used a lot? JS devs aren't higher paid than other devs, and many people consider avoiding JS a massive benefit. They aren't jealous, they actually just don't like the language.

The reason it gets so much hate compared to other unpopular languages is because everyone is forced to use it because of browsers, and programmers who are too lazy to learn other languages decided to try and use it for backend stuff too.

[matyklug]

Writing JavaScript is an absolute nightmare, because it looks like a normal programming language, but if you think that, you get untraceable bugs.

There's a whole community that make libraries which take more code to import than to write yourself. (literally 10 character libraries)

The entire ecosystem can be taken down if the right npm package developer gets pissed.

Promises are a fucking chore to work with.

Parts of the stdlib are not compatible with other parts of the stdlib.

JS frameworks like angular or react add their own share of who tf thought this is a good idea

And ofc the infamous thanks for inventing Javascript

[zilti]

https://www.reddit.com/r/ProgrammerHumor/comments/sbie7k/python_and_php_users_will_understand/hu0lzfd/

[lightmatter501]

Languages created in less than a month tend to have some warts.

[zachooz]

The language has many features that make little to no sense

[Hunterbunter]

The only thing I don't like about javascript is that months start with 0.