Why do people make fun of JS?
Posted by Personal_Factor568@reddit | learnprogramming | View on Reddit | 165 comments
Curious since I've seen lots of memes making fun of JS, ik it's just for fun and probably not serious but surely there's still a reason for it
ImportantMoonDuties@reddit
Basically, they stripped off all the warning signs and safety equipment because newbies don't know what the signs are talking about or how to use the equipment, so you can just stroll right up and start working on things easy-peasy, but later on they'll try to do something the sign would've warned them about but it's not there so they get their arm torn off instead.
Personal_Factor568@reddit (OP)
Ahh so it's both very newbie friendly and unfriendly in the same time
Bullwinkle_Moose@reddit
Yeah writing JavaScript is very easy. Writing good JavaScript is very hard. There are also multiple ways to do the same thing. By contrast Python can be (relatively) more restrictive in how many ways you can do the same thing, but that creates a sort of cohesion across all code bases. On the opposite side of the Python coin is Ruby which is frequently compared to Python. Ruby gives you a lot more rope to hang yourself with because like JavaScript, you can do the same thing in multiple ways. Because of this the Ruby community has adopted a "Convention over Configuration" approach and there is a strong adherence to "the right way of doing things" - What this means is that there is a conventional "style guide" on how you should code, how methods should be named, structured, etc. (In Ruby land, just because something can be done, doesn't mean it's to be done).
JavaScript seems to have the fluidity of Ruby but without the guard rails (no pun intended). It's also a common entry level language, so when you look at JavaScript code you will see all sorts of weird and questionable approaches to how people have solved problems. With this in mind, when you look at ruby or python code bases both tend to have a certain structure (to varying degrees) but with JavaScript this seems to be less so. (Obviously these are gross oversimplifications so take it with a pinch of salt).
Historically JavaScript also lacked things like "includes" functions on arrays and other similar functions deemed standard in other languages, so there could also be a bit of a historic stigma too.
In conclusion there is no single reason, it could also just be that it's "JavaScripts turn", previously php was the but of many programming jokes.
novagenesis@reddit
I never got the "Python can be more restrictive", though I've heard it a lot over the yeras. It is as TIMTOWTDI as JavaScript or Perl in my experience.
It's always a language that got popular past the "next big thing" that isn't "boring and static". I grew up in Perl shops, and boy did everyone make fun of it.
Souseisekigun@reddit
Doesn't Perl have four ways of writing if statements?
novagenesis@reddit
Yes. There is more than one way to do everything. Perl allows
ifclauses before OR after, like where clauses. But that only gets you to 3 if you include ternary. Perhaps inline ampersands are a fourth?Bullwinkle_Moose@reddit
Yeah ternary would be another one. You also have unless statements, and also logical operators (or/and) for short circuit evaluation. I.e.
$condition or something_elseGoing back to Python being less freeform than JavaScript, it's to do with the language design aimed at reducing"magic". One example is in type conversation (Explicit Vs Implicit) - Python prefers explicitness and discourages implicit type conversion that can end up being very confusing. JavaScript has no such qualms. You're free so do stuff like this
let x = "5" + 5which gives you the string "55".So the reason why people say JavaScript is more freeform is essentially little things like these that let you sprinkle "magic" across the code base that can get very confusing in large projects unless you enforce a style guide. Ruby has a general community consensus as to what is allowed and what isn't, but JavaScript doesn't seem to have a community consensus in the same way. Anything seems to go in the JavaScript world. It tends to be project specific rather than ecosystem specific.
liquidInkRocks@reddit
It's not hard, it's just easy not to. When baby programmers learn bits and pieces from fragments of YouTube videos and free tutorials, they don't learn structure and design. Then when they need structure and design, it's too late to overcome their bad habits.
Freeman7-13@reddit
I think this is me. I just finished my first JS project. Is there an online resource that teaches structure and design?
PixelBlaster@reddit
In my personal opinion, the best way would be to simply learn a statically-typed language like Java or C#.
reallyreallyreason@reddit
I don't really agree, as a professional JS developer. Writing high quality, performant JavaScript code is difficult and at the highest level requires intimate knowledge of how the engine's complex language machine works as well as a near encyclopedic knowledge of random trivia about engine compatibility and runtime feature implementations.
Kaenguruu-Dev@reddit
You have not seen my python code yet
wggn@reddit
some things are not meant to be seen
HolyPommeDeTerre@reddit
Full of invisible traps
cursedproha@reddit
This
cosmic_cosmosis@reddit
Why even comment?
cursedproha@reddit
It was joke about “this” behavior in js that depends on a context and can be example of invisible trap.
cosmic_cosmosis@reddit
Ah I fell for the trap. I see a lot of Reddit plagued by comments that just say “this” and don’t offer anything else. I guess I really whooshed it.
GuyOnTheMoon@reddit
This ^
novagenesis@reddit
Yes... and no.
What people tend to leave out is that IDEs and libraries have gotten REALLY good at creating those signs for you dynamically through introspection. If you use Typescript and run a linter, you have comparable safety equipment, while still having some of the advantages of being able to jump out of a plane if you want to.
For people in certain domains, it's actually a well-structures language. I (and many like me) was a career Perl developer for years before node.js took off; and our peer languages were php, ruby, and python. None really have training wheels.
It's the stuff of Hatfield v McCoy arguments, but there are plenty of downsides to the more structured languages, mostly WRT expressing an outcome as a series of steps efficiently. The most iconic example is programs dealing with unstructured I/O data having to output other unstructured data. For a lot of us, that's more than half the job, and I wouldn't code algorithms in Java or C++ in that domain.
The web is polarizing as hell. In theory, everything you see on HTTP is largely unstructured and foreign data. There are reasons to build your backend in a more-structured language, but there are seriously upsides to having something like javascript on either side of the coin. But as a newbie, you might not benefit from those things the same way you might suffer from how they don't punish bad design practices.
Souseisekigun@reddit
Well, yes, but at that point you're using a different language explicitly designed to address the flaws of JavaScript which effectively concedes the point.
novagenesis@reddit
Not really. Typescript is a language, but not in that sense. It's a type DSL that allows you to more robust compile-time type power than most language allow. But typescript is ultimately just decoration-based. Nothing in typescript influences the output code, and anything you could have done in typescript that resembles "normal" static language code could be done using jsdoc instead. It's just a type linter.
More importantly, it runs on the fact that most of us have never seen dynamic typing as a flaw. There are powerful design patterns that just don't work in static languages. Typescript has escape-hatches everywhere, like every good linter. And there is always a good reason or 12 to use them.
Typing is a big part of the reason for Greenspun's 10th Rule: Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.
You can do anything in static languages, but so many famous Design Patterns serve no purpose but to give those languages halfass versions of things that come free in the Perls, Pythons, Javascripts, Luas, etc of the world.
RonaldHarding@reddit
Its everyone unfriendly. Experienced developers are far more likely to step on a land-mine in JS than in a strongly typed language.
akoOfIxtall@reddit
It's that curve meme all over again
"I don't understand javascript | | \ \ Js is actually quite simple / / | | I don't understand javascript"
mleclerc182@reddit
Saving this, fantastic analogy/explanation.
TheSpiffySpaceman@reddit
It's like using a screwdriver made out of rubber.
You can call it flexible, but....should it be?
dopplegrangus@reddit
Can you give an example of these "dangers"?
craigthecrayfish@reddit
Implicit type conversion is one. For example, a comparison using
==of two falsy values will evaluate to true even if they are of different types. The Number0will be considered equal to all of these values:'', '0', undefined, falseYou can get around this using strict equality with
===, but beginners who don't know better (especially if they've seen==used more commonly elsewhere) can end up with some difficult to find bugs.novagenesis@reddit
This is where the "people just like hating on JavaScript" folks get their ammo. Implicit type conversion is found in more than half the languages out there. And while the null/undefined thing is a little confusing, javascript's type conversions are downright sane and defensible compared to those of some languages.
EmotionalAlgae1687@reddit
A lot of this is indeed blown out of the water. With the base of the language being so simple, learning about these quirks is equivalent to learning intermediate level of any other programming language. A problem I do have with it, is that these learning bits of required knowledge are, as opposed to in other languages, less visible, which can be a risk in a tool with high adoption among less formally trained/professionally experienced developers. This with the fact that JS is more likely to produce undesired side effects, rather than crashing outright, can lead to some less than desirable situations.
novagenesis@reddit
I can see that. Everyone has shipped something with
==instead of===somewhere.But that is (or should be) less true in an actual job. You should have a company-wide eslint setup that catches any operations that would lead to weird outcomes. Nearly 90% of gotchas are the
eqeqeqrule in eslint. Done! And then you have Typescript'srestrict-plus-operandsfor everything else in the famous lists.But yes, this is TERRIBLE for a startup shop of people right out of college where nobody has told them about linting or best practices.
...but if I'm being frank, I've had the opportunity to see "we wanted to try a new language" projects in Ruby (rails) and Python (django) that were just as terrible in their own way. Nobody should be running a business letting people write projects in a language that NOBODY knows best practices for.
While I agree, this is true of many languages. Typescript is a better tool to mitigate those situations than many of those languages will ever support.
tasbir49@reddit
'0' means 0
0 is false
Therefore '0' means true!
'5' is 5. '1' is 1
Therefore '5'-'1' is 4, and '5'+'1' is '51'!
tasbir49@reddit
Weak typing in general.
Like if you declared a field on an object, and then do a typo in accessing that field somewhere else, Typescript would immediately catch that while JS would allow you to run that code and cause hard to detect problems in runtime that can have unintended effects
platinum92@reddit
0.1 + 0.2 = 0.30000000000000004
mugwhyrt@reddit
That has nothing to do with JS
HealyUnit@reddit
That's not a Javascript problem, dude.
Lopsided-Basket5366@reddit
Coming from a PHP background (before all the nice frameworks did heavy lifting), I concur..
liquidInkRocks@reddit
Just like Python
Left_Somewhere_4188@reddit
Or in one word "footguns"
Packeselt@reddit
Because 1 + "1" = "11"
DevLaunch@reddit
Inconsistent frameworks, bad rep due to a lot of people who switch to programming use this language to try and get their career switch, which results in a lot of poorly written code, and also not being strongly-typed language is a deal breaker for a lot of people, myself included.
Defection7478@reddit
despite being an incredibly ubiquitous language (99% of websites run js) it's kind of shitty. It has a lot of weird behavior https://github.com/denysdovhan/wtfjs and the lack of typing makes it 1) really easy to pick up and 2) really difficult to scale to large projects (imo). The end result of which is noobs picking it up and many professionals instead preferring typescript.
It also gets shoved into a lot of places it probably doesn't belong, like mobile apps, on the server and in AI tooling, when its just supposed to be a client side language for the web.
Brilla-Bose@reddit
thats the whole reason its shitty. you can only add stuff not remove/break it. js got Dates api from java and later it changed in next java versions. but js just couldn't do it. any breaking change in js breaks the WHOLE INTERNET thought!
tiller_luna@reddit
JS is kinda like C ffs... Has a lot of weird s*t that cannot be fixed either because of overall language design or compatability, and it's everywhere in its scope, leaving no other option most of the time.
ElijahDaneelGiskard@reddit
No. It is not like c. C is very restrictive but less prone to shooting yourself in the foot
hanoian@reddit
Um that's some wild hyperbole. Have you ever made anything in C? It's a million times easier to make it in JS even with the few traps.
tiller_luna@reddit
It doesn't cross my mind to compare what is "easier to make" between C and JS because use cases of C and JS practically never intersect (at least for anything not from a textbook).
for context: i coded different things in C and in JS, and I strongly disagree with your comment
ListerfiendLurks@reddit
C is harder to make anything before you even START coding because of depencies. Have you ever had to write or modify a makefile for even a moderate project?
tiller_luna@reddit
makeis not C. Yeah, dependency management is kind of weak spot, and that's rectified with modern build systems and some discipline.ElijahDaneelGiskard@reddit
Oh yes , I'd hate making anything real world in c . I'm just saying it's very well structured, so if you manage to make it, it's very unlikely you did something you didn't intend to , or used some syntax / Mathis you don't understand properly , which is very common in JS i guess ?
novagenesis@reddit
Since when? Are you arguing "since it segfaults every 5 minutes, it won't do something you didn't intend!" or do you genuinely think 1000 lines of C are going to have fewer unintended side-effects than the 20 lines of javascript that do the same thing?
Hopeful-Sir-2018@reddit
C can be super weird. For example - you should never use
printfto display user created text.For example read this and the bugs section right under it: https://www.man7.org/linux/man-pages/man3/printf.3.html#CAVEATS
But you'll find a FUCK LOAD of tutorial books that never, not once, mention these. In fact they specifically use the things they aren't supposed to be doing.
However JS has a fuck load of other unintended things. I've yet to meet any experienced programmer that prefers JavaScript over C, in any level and in any environment, in real life. To be fair - those are usually two very distinctly different environments though.
JavaScript is The Worlds Shittiest and Most Used Language because of how the Internet matured.
It's going to take some serious effort to change things - and I suspect it'll happen eventually. TypeScript has done a lot of legwork.
Wait, to be clear you think 20 lines of JS is equivalent to 1k lines in C?
novagenesis@reddit
I prefer JavaScript to C, and have been programming professionally for over 20 years. Last time I worked on an embedded project, the company I worked for picked embedded node.js over C and estimated they saved hundreds of thousands or more despite the increased production cost for the unit.
After having worked professionally in VB6, C#, Perl, and Python for about a decade, I maneuvered myself into a dedicated backend-JavaScript position for most of my senior career both because I like the money AND because I like the language and dev environment. Despite the fact I have always been a backend-primary full-stack developer or a (low-scale) backend data-flow engineer.
If you've ever programmed perl (or php I suppose) professionally, you know this statement is at best hyperbole. Javascript is a great language, and it was careful decisions by big players that led to it becoming dominant on the backend. Hapi (the reason I started taking node.js seriously) was not an accident.
I agree that Typescript is pretty awesome. The best part is that it's just a linting DSL and that you can circumvent it when necessary.
Wait, to be clear you think that no language ever invented is anywhere near as bad as Javascript? Obviously not. It was hyperbole. In most programs, my JS to C ratio is 10:1 to 20:1. I could probably become a better C developer and tighten the gap.
Hopeful-Sir-2018@reddit
That's some pretty amazing deflection there, I'll grant you that. The hyperbole was unneeded. It undermined your point.
And yet I'll still never met someone, in real life, who said that. I've some some odd folks on the Internet, like yourself. But there are also people who claim to like Brainfuck. I'm sure they do.
To be fair, VB6 had its place and filled it well given the options that were available at the time. The second C# was released with .Net practically everyone abandoned Visual Basic. It also didn't help that VB6 didn't translate well into .Net and C# felt like an upgraded Java.
There are two era's of PHP. There's everything 5 and earlier and everything 7 and beyond. They are quite different.
Mild hyperbole. Meaning every sane person would rather JS over Brainfuck. Pretty much no one would favor JS over C#, for example.
There's a vast difference between liking something and doing something because it's profitable. There's a reason JavaScript is consistently one of the most hated languages.
Primarily the only people who like it are newbies, people who are paid well to deal with it, and a small niche group who claim to like it.
I'm genuinely hoping in the future we dump JavaScript primarily in favor of TypeScript somehow or another. But I know it'll "never" happen in the same people I still hear the whispers of IE6 in a dark cloud.
novagenesis@reddit
You're kinda going off a deep end here. Please keep it civil.
So you're saying I'm fiction, or that my demographic is fiction? I've worked at quite a few businesess that were node.js shops. Everyone was there by choice. I think you have an Affinity Bias here.
When I worked in VB6, it was the wrong tool for the job and I was too junior to realize that. We had 4 devs writing CSV transforms in VB6 with silly UIs. I worked alone in a high-frequency CRM (collection call harassment shit, unfortunately) division and managed twice the total throughput of that team. When they pulled me back in, I pieced together something in C# and python that replaced all their VB6 transformers for a year.
I'm happy to admit ignorance of anything that new with php. By 2010 or so I hadn't touched php until I got stuck with it in an inhereted wordpress site 2 months ago.
I've worked at two companies on the team porting C# to node.js. The more recent of which was a fairly large retail acquisition with all their inventory systems written in unmainainble C#. Pretty much no one you know would favor JS over C#. NestJS compares favorably to ASP.NET in every way. And I run a team that maintains a C# app as my day job (and no, I'm not blowing the money to port it to JS), yet I still prefer javascript to C#. C# has admittedly come a long way since I previously jumped ship from it back in 2012 or so. The "one main solution to each problem" issue isn't a feature where I come from. I'd kill for a Prisma or Drizzle port in C# instead of EF.
Oh I bloody LOVE Javascript/Typescript. All my side projects, all my hobby projects. I wouldn't be caught dead using another language.
According to whom? Here's stackoverflow blog (a bit outdated, but it shouldn't change much) with Javascript on a preferred position and Typescript near the top for least hated language.
And sveltekit is consistently the "most loved" full stack web framework.
Perhaps you and your friends just hate javascript because those mean decisionmakers make you use them?
MASSIVE not-so-niche group who claim to like it. NPM dethroned CPAN as the biggest package repository in the world because fucking EVERYONE hobby-codes in it.
They're the same thing. All modern javascript engines these days will run typescript code even if they won't typecheck it. All typescript is is decorators for type analysis.
IE6 finally died. My clientbase includes large institutions who are the LAST to change. We killed IE6 support in 2020 and had all of 2 complaints. And a little pressure to their IT team talking about security requirements and they updated their folks.
hanoian@reddit
I've only made a compiler as part of nand2tetris in C, and it was immensely complicated compared to any other language I've ever used. I also did a course of it in uni and while I loved the challenge of making interesting and beautiful code, I found it to be the most absurdly odd language I've used.
The footguns etc. people talk about in JS are like a meme in my mind. Use === and it gets rid of a lot. Use TS and it turns into a good but sort of annoying language.
I think the hate and mockery are largely unjustified. It's fast and reliable on the server and obviously required for the browser.
novagenesis@reddit
I fence-sit Typescript. I LOVE it and use it at work, but sometimes I feel if I got a bit less religious and used some
as anyin crunchy sections I'd be a lot better-off.I love/hate typescript for metaprogramming. Wired correctly, Typescript can express the type mutations of literally any programming pattern. I dare an intermediate Typescripter to actually encode anything more complicated than currying into their typedefs.
Souseisekigun@reddit
It's like C in that it's very easy to walk into a trap because of some obscure weird thing and when people complain about the response is that it's a skill issue and they need to just memorize all the obscure pit falls (instead of admitting that a language should be designed such that engineers do not need to memorize obscure pitfalls). Though at least with C some of it understandable as opposed to just being bad language design.
Brilla-Bose@reddit
don't think so!
https://youtu.be/mnqU9YdjX_c?si=he6zyJLoA241dp1k
https://youtu.be/oTEiQx88B2U?si=LZTKQZia-GtuZ2X6
tiller_luna@reddit
Dozens of UBs that work fine 99 times but corrupt process the 100th time say hello
xenomachina@reddit
Even in the beginning it was a toy language. However, back then it was only meant for stuff like changing images on-hover, and putting dynamic text in the status bar, so that was "fine".
It's like if someone tried to build a real building with Lego. Seems easier at first: no need to learn carpentry or any of the skills normally needed for construction. However, the more you build, the more clear it becomes that it isn't really the right tool for the job.
Brilla-Bose@reddit
agree that it's not perfect, but we don't have any other choice for frontend until web assembly becomes a thing)
PPewt@reddit
Java still has the old dates API too. The issues with JS are a bit more structural, e.g. how
==works.Brilla-Bose@reddit
can they change the behaviour of == ? no, right? since it will break all the websites using it already. so they introduced ===
PPewt@reddit
I understand why they can't change it. The point is they made some really questionable decisions in the early language design which are so structural that they're hard to escape from, whereas old APIs are far easier to deprecate.
lIIllIIlllIIllIIl@reddit
JavaScript has a track record of adding new "modes" that remove the bad stuff.
For example,
"use strict"completely changes the way variable declaration and scoping works and completely removes thewithkeyword.Scripts with
type="module"also have an entirely new syntax and scoping rules that are incompatible with old scripts.The general philosophy however is to just add stuff that's better than the old stuff. For example,
varhas been superceded byletandconst, The Dates API is being replaced by the Temporal API, etc.bhison@reddit
Javascript isn't shitty, it's fucking amazing, but it's fucking amazing at doing what it's designed to do which is always try to run no matter what's been passed to it. Like an apple is a shitty orange but that's because it's not supposed to be an orange.
Yamoyek@reddit
And that’s one of its major problems lol. Programs should fail loudly and fail early, not just try and act like everything’s okay until it all crashes and burns a few hundred lines later.
Rarelyimportant@reddit
Except it's not even that good at the one thing it's supposed to be good at. It's not that hard to get JS to NOT run. And even if it were good at it, there's a reason every other language chooses to go with the "crash when things get out of hand" and that's because typically when things start going off the rails, unexpected things happen. And whatever programmer couldn't avoid things going off the rails in the first place, is unlikely to be able to save it with exception handling. It's like a lawnmower. If a lawnmower can detect that it's upside down, it might be good to turn the blades off. There's not really any good reason for a lawnmower to be upside down and the blade still spinning. JS says, whether it's upside down, or chewing it's way through someone's leg, let's just keep that thing spinning. Which is a silly design, and again, it's not even good at doing it.
CountryBoyDeveloper@reddit
It’s exceptional at doing what it was made for if you know how to use it correctly.
craigthecrayfish@reddit
JavaScript was designed with the intention of being run in the unpredictable front-end web environment, with lots of input and user interaction, as well as to be easily approachable. If something goes wrong on a web page you usually don't need or want a crash.
I'm not going to argue that JS is an example of great design, and it certainly has its quirks, but it generally does achieve its objectives.
bearbarebere@reddit
JS is awesome and I’m tired of people claiming it’s not!
tiller_luna@reddit
Way too sensitive to
undefineds to "run no matter what's been passed".JS was designed "in 10 days" by a small collective for a proprietary browser for poorly (if ever) standardized web for a wild mix of expectations (like "resembling Java, cause we decided to run Java applets").
bhison@reddit
what should it do instead when something is undefined? automatically coerse to 0, false, "" etc? I think that's an intentional decision based on community feedback. It's not hard to preface things with "!!" or suffix with "?? foo"
Rarelyimportant@reddit
I mean it coerces everything else, so why stop there? I think it was an intentional decision so that JS could add "inconsistent" to its list of shitty qualities.
novagenesis@reddit
The v8 runtime is speed-competitive with Java or .NET and node's event loop creates phenomenal concurrency handling. From a "tool for the job" perspective, it's a hand-in-glove fit on servers now. I've been involved in some crazy IoT stuff in javascript.
As for mobile apps, I think that's an indefensible take anymore. HTML is the crowned king of UI. If you have any resources to spare at all, you're going to provide end-users a better UI experience in HTML than any other library, and usually with better cross-compatibility. And Javascript is in bed with HTML. I'm not saying there's never an argument for non-javascript mobile apps - of course they are viable as well. But javascript has both the speed and flexibility to be a solid mobile-first language.
...100% with you on AI tooling, though.
liquidInkRocks@reddit
<incredibly ubiquitous
Just ubiquitous. If it was incredible, it wouldn't be ubiquitous.
Personal_Factor568@reddit (OP)
I've read that typescript are basically better js is that true?
Defection7478@reddit
It's js with strong typing. Whether or not that's an improvement is situation dependent.
crazy_cookie123@reddit
TypeScript is a superset of JavaScript which means all valid JS code is also valid TS code (assuming the correct compiler options). The main advantage of TS is static typing, which allows you to say a variable is a certain type and allows you to know the variable will always hold data of that type. That makes it significantly easier to avoid a lot of common errors. TS is also easier for a computer to read so you'll usually get better code completion in your IDE.
KBrieger@reddit
It's typed js.
LForbesIam@reddit
Because Java script is sloooooow. JavaScript was great before CSS got so advanced. Now it is a pain and has to be updated all the time and has security bugs.
I use CSS, C#, and PHP and avoid JavaScript at all costs.
nekokattt@reddit
PHP is far slower than Node
PHP is just as bad though. There has been a high/critical CVE raised for PHP at least once per month since the start of this year.
LForbesIam@reddit
Java script is slow. Css and php are pretty fast.
wonderfulninja2@reddit
Ignorance. I like to code in C++ and Javascript, both languages allow lots of freedom but that comes with a cost: people who didn't acquire good coding habits or don't fully understand what they are doing suffer a lot.
sufanLL@reddit
Mostly wtfjs
Down_it_up@reddit
It is so fucjijg annoying
Extension_Anybody150@reddit
It's just their opinion, and there's not much we can do about it. Any language can work well for some people and might not for others. It all depends on the project and personal preference.
bhison@reddit
Most people who complain about JS are shit at JS. Git gud.
v_e_x@reddit
This criticism is valid, I suppose, but it only goes so far. There are mistakes built into the language that we have been building on for decades now. Douglas Crockford, a JS expert who has been working on refining and bettering the JS language for years, and who created JSON, has a good point as well. It's time we started to think about its replacement. The language itself is fundamentally broken, and needs to be eventually replaced. It will be a huge task, but it eventually has to happen.
Why We Should Stop Using JavaScript According to Douglas Crockford (Inventor of JSON)
https://www.youtube.com/watch?v=lc5Np9OqDHU
novagenesis@reddit
He then goes on to say it's still the best language in the world for what it does.
He's not saying we should stop writing Javascript and use any other language in the world. He's saying we should invent a language that's better because there isn't one yet.
jacobprogramz@reddit
Much of the criticism comes from its poor style, speed, limited applications, etc, which I understand. JavaScript is rapid, it isn't pretty or incredibly fast. For the code purists, go back to programming in machine code lol. I have written many 70,000+ line monstrosities in my lifetime, and not once have I complained about code being easier to make.
JS is incredibly useful and has large frameworks for designing front and back ends to websites. I haven't used them as much, as I coded all my websites from scratch for my company when I was younger, encryption and all. Every line of HTML, CSS, PHP, and JavaScript. I didn't even really use any imported libraries. I miss having that kind of energy.
Not only was it incredibly hard to understand when I was younger, but also, it took hundreds of thousands of lines, and thousands of hours. When I began, this information wasn't as accessible, and also, code was still mostly restricted to CS majors in corporations. To say the least, younger people have it way easier now.
Now I see people just building their stack and rapidly assembling websites. I sometimes do feel old. Hell, I didn't even import packages until later on, and I started out typing my code in notepad cause I taught myself very young. I was about 7 when I began using the command line and experimenting with computers. People have IDEs, AI, and massive libraries that can build things far more rapidly.
Certainly, it may not be as mature or as fast as other languages, but JavaScript was one of the first languages I learned, and in my time I have seen it grow exponentially. I have been programming for over a decade, and I can still say that JavaScript is one of the best languages to know, especially for rapid website development in the modern era.
Python is quickly closing this gap, at least in the GUI department, but for the application of building websites, I feel as though python really hasn't hit what JavaScript has been able to do the last few years.
For most programming applications, it is simply easier to make the code more accessible to a broader audience, even if it isn't as optimized or pretty as you'd like it to be. JavaScript has succeeded in making code easy and fast for many people. I know because I learned it at 12, and even back then, it was easy. Now I know 9 languages, and JavaScript I don't use as much, but that doesn't mean I don't come back to it occasionally.
novagenesis@reddit
Javascript beats about half of machine-code-compiled languages. Depending on the benchmark, v8 is coming out ahead of LuaJIT, which makes Javascript the fastest "interpreted" language out there.
marvinhozi@reddit
It’s basically a language that doesn’t protect you from common problems, some of which the language has itself created for you to experience the joys of.
significantairport9@reddit
They want to let the world know that they're better than people who use JS.
Left_Somewhere_4188@reddit
This is the most honest answer. The the most loved languages are ones no-one actually really uses. Think Rust or Haskell or Clojure. Even with JS frameworks look at Astro.
As soon as a lot of people start using a language, the cult mentality dissapears and people start finding glaring issues with it. Or it flips completely and everyone loves to say how much they hate it.
YahenP@reddit
With JS, it's different. No one forces you to write in Haskell or F#. There are always alternatives to any language. But not for JS.
novagenesis@reddit
Because the alternatives died. VBscript died. WASM isn't taking hold like people were hoping.
Javascript kills all the alternatives. And it's starting to dominate the backend in the same way.
People who hate javascript might have a disappointing future in their workplace.
minneyar@reddit
I use JS more than any other language nowadays and will still gladly say that JS is a garbage language. TS makes it a lot better, but the whole language is still just a bunch of quick hacks that were quickly piled on top of each other because they seemed like good ideas at the time, and now they're permanently enshrined in the web browser forever.
PartyParrotGames@reddit
Oh boy, well if you use javascript enough you'll come across some frustrating problems that really seem like they shouldn't be how they are.
Here are some examples:
Maybe the most notorious example
```
[] == ![] // true
```
Type coercion confusion
```
[] + [] // ""
[] + {} // "[object Object]"
{} + [] // 0
{} + {} // "[object Object][object Object]" or NaN (depending on browser)
```
Inconsistent behavior of this
```
const obj = {
method: function() { console.log(this); }
};
obj.method(); // logs obj
const method = obj.method;
method(); // logs window (in non-strict mode) or undefined (in strict mode)
```
Floating point precision
```
0.1 + 0.2 === 0.3 // false
0.1 + 0.2 // 0.30000000000000004
```
I could just keep going on and on with frustrating examples that make me question the sanity of the javascript language, but I'll stop here. You can find many more examples online easily.
HonzaS97@reddit
There are lots of weird quirks in JS but IEEE 754 which practically all languages use for their floating point arithmetics isn't one of them.
HealyUnit@reddit
Absolutely. I'd also argue that the "inconsistent behavior of
this" stuff is completely consistent. In one case, you're calling the function from the execution context of theobjobject, and in the other, you're calling it from the context of the global object (in the case of the browser, thewindow).Sounds more like this guy doesn't understand what
thisis, than any real complaint here.dylanonymous12@reddit
Go try JS then get back to me
mugwhyrt@reddit
The code above will run without issue even though it has what would be code breaking syntax errors in any other language. People make fun of JS in part because it's easy to come across stuff that just shouldn't work for very basic reasons, but does because JS is unreasonably flexible.
nekokattt@reddit
;;; is valid in other languages though, most notably C.
mugwhyrt@reddit
Well then C needs to get its act together too
lorean_victor@reddit
I think it’s because it’s the language you can make fun of without really offending people. not a lot of people would be ideologically in love with a language that suggests not using its basic comparison operator (==) and still hasn’t got importing code right (ESM is pretty cool but the fragmentation is crazy). it lacks any strong design principle or identity, and for the foreseeable future will remain as such as unlike most other languages it needs really really strong backwards compatibility, further contributing to that lack of ideological devotion.
for me personally, this messy nature is what makes JS pretty attractive. it’s trying to be just a tool to get the job done instead of a philosophical framework of approaching problems, and I appreciate this pragmatism and understand all the ridiculous messiness that comes with it.
armahillo@reddit
The first version of JS was literally written in a week, was never intended to be used in all the ways that it is today.
I dont hate JS. I find it annoying when mid-level engineers try to solve every problem with JS because thats where they started. It has its place.
EmotionalAlgae1687@reddit
Extremely painful learning, after multiple years of experience.
Both Number.toString() and parseInt() do not always default to base10.
MetaSemaphore@reddit
Folks have given some good answers but haven't really explained why JS is particularly...uh...quirky.
Most programming languages (Java, Python, etc.) run in quite controlled environments. You can control not only your own program, but also (to some degree) the context in which they run. Even when you write a program in these languages to run on a user's machine directly, it gets compiled and packages up into its own, largely isolated, thing.
JS runs on everything from smartphones to high powered PCs, as interpreted through any number of browsers that historically only loosely agreed about how to run it. This has gotten a ton better over the years, because now browsers are all "evergreen" and get updates for new features/fixes--it used to be that you had to make sure your JS worked on IE 11, but also IE 10 and 9 and 8, all of which behaved slightly differently.
Frontend code also tends to have a lot more varied user interaction than, e.g., code that can focus solely on business logic, so there are a lot of messy edge cases that need to be accounted for in a lot of JS code.
Lastly, JS doesn't really get to be versioned in the way other programming languages do. The expectation for web sites is that they have backwards compatibility forever. Hamster Dance and Zombo.com still work on your new PC (they may not look good, but they work). So a lot of the questionable choices that were made when JS was first invented (like the behavior of 'var') can't be completely changed. In Python if you had behavior like that in v1, you would just say, "okay, var is going to be block scoped. Everyone agrees that's better, so we're changing it for all programs you write in Python v2." And you can do that without breaking the programs that were written in v1.
With JS, you have to keep 'var' as-is. Because if you change it, you're going to break every site written before 2016 or so. Instead of versioning, you layer new stuff ontop of the old stuff and hope it replaces it (e.g., no one should use 'var' ever anymore--they should use let and const...but var is still there). The skeletons aren't even in the closet; they're just out and about, hiding behind the nice new furniture.
But, with all that being said, writing JS today is a pretty good experience. The language has improved a lot since the release of ES6, gaining lots of modern fearures and tooling, and it usually feels pretty comparable to writing something like Python. And a lot of the JS jokes really stem from the state it was in 6-12+ years ago, when it was being used for big, complicated programs, but was still essentially a quirky toy language made for sending web forms.
liquidInkRocks@reddit
Much of this also applies to Python.There's a veritable plethora of Python interpreters: IPython, CPython, Iron Python, Jython, RPython, PyPt, yada yada yada. There are popular libraries not backward compatible. There are IDEs bound to particular interpreters.
And C as well.
await_yesterday@reddit
Ipython is CPython with a fancy repl. The rest are a rounding error Almost nobody uses them. CPython is the only game in town.
MetaSemaphore@reddit
Fair enough. I've only written Python in a pretty controllable environment (making backend APIs), so I'm sure I have missed a lot of these nuances and quirks of Python, and I was likely oversimplifying.
hjd_thd@reddit
The reason why JS is so quirky is because it went from not existing at all to becoming standartised in just two years. A classic example of a quick bodge becoming the cornerstone of a large sector of tech.
daripious@reddit
That's not the reason, it fundamentally is a poorly designed language.
Yes it's a lot better these days, but under the hood there's a gremlin running the show who's motto is "fuck it why not"
TheNewOP@reddit
It's perceived to be easy. Dynamic language, a language that many bootcamps/tutorials use to teach programming. Similar to Python.
It's perceived to be a bad language. No STL, weird interactions, ESM is technically not at full adoption yet, lots of older chaotic code (though this exists in pretty much every language >X years old, e.g. if you're in a really old Java codebase using anonymous inner classes to simulate closures). It's easy to fuck up.
Hate begets hate. It becomes easy to meme on something and run with existing jokes. Similar to Java in the old days.
(I write JS for a living but use TS cause it makes JS less batshit.)
Michaeli_Starky@reddit
https://youtu.be/et8xNAc2ic8?si=us8wBIC3N0MyN4zL
It's fun to make fun of JS
I_Am_Astraeus@reddit
Two real reasons. The language has evolved so you end up with things like null + undefined + NaN + empty, which feels excessive. Additionally most people prefer strongly typed languages, a no guardrails language means you just end up with a ton of bugs most languages could catch at compile time.
InvisibleHandOfE@reddit
Learn a strongly typed language and understand why they are strongly typed and you will understand.
Personal_Factor568@reddit (OP)
Excuse me for the noob question, but what does strongly type mean? Is it like telling the variable what data type it's allowed to accept?
formalcall@reddit
There isn't really a clear definition of what strongly typed and weakly typed mean. Among other things, I consider a weakly type language to be one that has a lot of type coercion. Type coercion is one type being implicitly converted into another.
For example, in JavaScript you can concatenate a number and a string together, and it will implicitly convert the number to a string. The language does not require you to convert the number explicitly, for example, with a cast or some conversion function.
qpazza@reddit
And also what data type a function returns
loxagos_snake@reddit
Yep. Once something is declared to be a string, it's a string from now on. You can't assign it a number down the line.
A lot of reason newbies are drawn to it is that, well, anything goes. So you get variables called "x" that start as numbers and then maybe you are in a mood to assign a string to them instead of declaring a new variable.
Then you try to build bigger stuff and of course, other than being impossible to reliably debug, everything breaks all the time because your code gets different input than what it expects.
People like to shit on TS too, but on every big project I've worked on (read: anything beyond a simple website or a calculator app) JS was outright forbidden. There's a reason for that.
Rarelyimportant@reddit
The idea of TS is better than the reality in my opinion. Typescript has so many ways of doing type assertion, either explicitly or implicitly, and any time you assert a type, TS just says "OK, if you say so, it's that type". The whole point of typed language is that it doesn't matter how smart you are, or how good you are at programming, keeping track of all those pesky little things perfectly is hard, so let's have the computer do that. But with TS it's more "let's have the computer do that, unless you unknowingly told it not to, or unknowingly told it something of TypeA was TypeB, now it's type checking the wrong type". The amount of times I've had some problem in TS that I can't figure out, go to Stack Overflow, find some solution that fixes my problem, only to later find out I'm just doing type assertion is yet some other hidden way, it can get quite frustrating.
gpexer@reddit
Remember, whenever you are using type casting you are basically taking control from the type system, and relaying on your judgement. Whenever I see a type cast, I know that's potentially going to fail, like in this example, ts warns you that you cannot access "swim" or "fly" until you do the type assertion, but for these "short" types you can use:
But even with the type assertion function you should use "in" operator.
loxagos_snake@reddit
I don't disagree with you, although I've never had this situation happen. It's definitely not like C# where the compiler will have your head on a pike immediately if you do funny shit.
But IMO this is actually an argument for Typescript. It's giving you all the tools you need to be as safe as possible, but is not going to claim that it knows better. I personally stick close to the guardrails and work in the simplest way possible with it, even when building complex systems.
As you said, the example is not how I would personally do things and it's possibly there to appeal to the JS folks. I never define multiple return types, for instance: my function would either return a Fish or a Bird, period.
InvisibleHandOfE@reddit
Newbies are typically unaware of the importance of stability, security and maintainability of any real-world project, the more people work on a large team project, the more people prefer a language that ensures only 'good and safe' code can compile. Rust is one such example, it's difficult to make the compiler happy, but you hardly have to worry about safety once you pass the compiler. So mistakes are detected early, unlike in JavaScript, your shit can magically work for wrong reasons, and makes it difficult to debug when it eventually explode
h00manist@reddit
Yep. Look at C# for example. You define a variable type and can only assign that type to it. So you can't make a mistake like add a number to a string, or check if True or False using a numeric type var.
In javascript you do wierd wild and wacky operations on variables of different types and it just produces a super weird result right back with no warning.
At least that's what I understand, haven't tried in fact
ConfusedGrasshopper@reddit
The wild west of programming
ScaredNoise1246@reddit
People are stupid plain and simple. You need to master JS to become a well-around developer. That being said, I respect everyone's journey.
RickFishman@reddit
Extremely loosey-goosey, no data type safety, etc. You could REALLY mess up using Javascript and it would give you no warning whatsoever.
PureTruther@reddit
Because they are not programmers. They are document creators, and they encounter programming first time.
ReversedBit@reddit
var foo = ‘string’; var bar = foo; //oh oh I am cast to a number
ngugeneral@reddit
Here's your answer (for real)
There are 2 types of programming languages: the one you hate and the one you haven't tried yet. A lot of people tried JS.
yksvaan@reddit
It's a poorly designed language that's intended to do minor clientside functionality on websites. Actually it works quite well for that but people add it everywhere. It shouldn't be used for anything but browsers really.
Imagine building an app only using Excel formulas
MuaTrenBienVang@reddit
Why you are not asking why people make fun of PHP?
bhison@reddit
The thing is most devs will never come into contact with PHP these days apart from the vibrant discussions about it being shit/being the best language in the world. However they will actually come across JS in their jobs. PHP is comparatively niche.
wakemeupoh@reddit
No its not
YahenP@reddit
Because there are a lot of other alternatives to PHP. Backends are written in dozens of languages. From Java to Ruby. Technically, you can take almost any language for the backend. For the frontend, there are no options except JS.
halistechnology@reddit
I love JavaScript and I won’t deny that there are some quirks with it. In my experience though people are hating on it for the same reason that I hate on Java, they don’t know it very well and therefore they don’t like it.
YahenP@reddit
We laugh because the tears have long since ended. JS is such a shitty programming language that it couldn't even take first place in a ranking of shitty languages. And yet it has no alternative for the web.
So all we can do is laugh.
MaverickGuardian@reddit
Weakly typed programming languages shouldn't exist.
goldtank123@reddit
They don’t
cheezballs@reddit
I think JS is actually not too bad right now. It's very loosey goosey but it's also kinda easy to make shit work by duck tyoing things.
No_Place_6696@reddit
Honestly, I quitted learning to code because of javascript.
joestradamus_one@reddit
I'm basically learning, people love and hate it, and that I shouldn't even care and learn what I want to learn and/or what the job market around me dictates.
loblawslawcah@reddit
Because it's an absolute mess of of hacks stacked on top of each other to make it half usable.
Material_Pea1820@reddit
My favorite metaphor is this: in most languages with warnings you can shoot your self in the foot if you make a mistake but with JS if you make a mistake you end up blowing your whole leg off … basically JS let’s you go down crazy rabbit holes that don’t seem like a problem until it’s actually a major problem
CountryBoyDeveloper@reddit
Absolutely nothing wrong with JS, if people learn it properly. Any language is horrible in the hands of a bad developer. When someone can’t use something properly they make fun of it. I am a C# dev, but love using JS for a lot of things. Been in the industry 15+ years and I have seen everything made fun of.
NatoBoram@reddit
https://github.com/denysdovhan/wtfjs#-examples
Howfuckingsad@reddit
The language in its entirety is like some solo employee made it in 2 weeks. (This is about what happened.)
marquoth_@reddit
No, the very first version of it was like that. Modern javascript has come a hell of a long way, in large part due to the fact that it has a well-managed and extremely rigorous proposals process for curating the language in the form of tc39.
Howfuckingsad@reddit
Haha forgot to add "\s" remark lol. I meant to say that sarcastically haha. Actually the reason why I added the bracket portion too.
Fit-Boysenberry4778@reddit
Typescript changed my life tbh, I always saw people say they’re never going back and thought it was memes, but they were right.
I also noticed that you weren’t super familiar with a strongly typed language, here’s an example that used to mess me up sometimes in JavaScript:
Imagine you have an array you want to iterate through, you start your for loop: for (let id = 0; id < arr; id++). Do you see the issue? JavaScript wouldn’t have told you that you’re comparing id to the actual array (id < arr).
But in type script when you initialize the array your text editor should yell at you if you try to the same thing and say something along the lines of: you cannot do id < arr because arr is an array.
Basically it saves you a headache when you run your scripts/files
huuaaang@reddit
It's just not a very robust language but front end devs who don't know any other languages insist on bringing to backends.
Typescript fixes some of it, but that's just another layer of dependencies and setup that every project needs. I'd just rather use a better designed language from the start.
wggn@reddit
https://cybercultural.com/p/1995-the-birth-of-javascript/
Rarelyimportant@reddit
Javascript has a lot of people who will absolutely extol JS like it's the greatest thing ever "OMG Typescript is the greatest language ever, the type system keeps me so safe. React is the best and the only way to build cool, performant sites!". These people also tend to not know any other language besides JS/TS, and don't seem to be aware that just because they're writing
value as MyTypeeverywhere in their code, it's not actually giving them any type safety. It's hard to take JS seriously when it's such a mess with libraries and tooling, so anyone claiming it's the greatest thing since sliced bread is also hard to take seriously. Imagine a world where we're all forced to listen to Nickelback for half of our day, people are going to make fun of Nickelback, but even more so the people who claim Nickelback is awesome and that they listen to them for the other half of the day too.UnnecessaryLemon@reddit
I personally also don't get it, I never had [object Object] with Javascript.
ray10k@reddit
First, there is the anecdote that the original version of JS was made in under a week to be first to market. Second, in a lot of situations where JS has to choose between "error out" or "guess what the developer wants," JS chooses to guess. Finally, there is an expectation among employers that "if you can make a website, you should also be able to write the JS to make it interactive."
Which leads to a language that gets a reputation of being rushed, unpredictable and mainly used by people who are more at home in visual design than in software development.
On the other hand, it's also a language that is somewhat limited in how it can be improved, since for every counter-intuitive fallback for unexpected input, there is some website that plainly won't work if a more sensible default is used instead; there are a staggering number of (spacebar heaters)[https://xkcd.com/1172] out there.
Blauelf@reddit
The first version had no error handling at all, the language became actually useful with JavaScript 3.
Compatibility is such a big thing in the JS world, a certain feature got delayed because it broke some Microsoft web app. They can never fully get rid of their previous mistakes. Kind of like MS Windows.
Constant_Stock_6020@reddit
Lol. I learned c# at uni, had been using Python, c++ and C# before that, and I have never been so confused in my life, as the day I was introduced to JavaScript at uni. Of course it's a logical language, but it's not very logical intuitively. I haven't touched JS since my internship, but I love TypeScript. I suppose it's okay, but the lack of typing, really makes some weird code, when the code grows. Sure, I can read code and go "ah, that's how it works", but if I don't know the type, then it ends up in a lot of mistakes.
It's not like the any type doesn't have a use, but I really fucking hate writing out a any type and pressing "." and then get the entire universe of recommendations. And does it care if the method or field belongs? Hah! No. It just doesn't work. 😁(I'm a professional and probably sound like a dork, I'm sick, leave me alone and let me use my brain a bit 😡)
Whsky_Lovers@reddit
A lot of the derision comes from the good ol days, modern JS has come a long way. There are still pitfalls though.
TehNolz@reddit
Because it does some really, really wild stuff sometimes. There's logical explanations for all of it of course, but it can be incredibly confusing when you encounter one of these quirks. Browse through this repository and you'll see what I mean. These quirks also let you do things that no other language would allow you to do. See JSFuck.
Personal_Factor568@reddit (OP)
2 repository dedicated to shit on JS, ig the hate are more serious than I thought lol
StereoZombie@reddit
Don't conflate hate with valid criticism or words of warning. If JS didn't have so many strange quirks, you wouldn't be able to dedicate a repo to those quirks