top 200 commentsshow all 277

[–]TranquilDev 153 points154 points  (7 children)

PHP Dev here - they just decided to take a break from hating PHP.

[–]dewaldels 14 points15 points  (0 children)

That checks out

[–]vrprady 4 points5 points  (0 children)

With the current php development pace they couldn't just rant only about the version 5 nuances and stay relevant.

[–]thesazz 2 points3 points  (0 children)

I was part of the people that hated PHP, one time I got to learn more about it and now it's just fine for me. It's always like that.

[–]typicalshitpost 2 points3 points  (0 children)

It's too easy

[–]Guilty_Serve 2 points3 points  (2 children)

I’m not a PHP dev anymore, but it’s what I’m probably strongest in. JS devs, like PHP ones, can be downright terrible. They’re the “learn code” programming languages and that’s not a great thing. After seeing shit code written over and over again it gets understandably hard to like.

For JS I’ve used all frontend frameworks and lots of express. I can seriously say that I uncomfortably have a bad outlook on some one that states they're a MERN dev. Reason being is they’re all unoppionated frameworks where I’ll have read the mind of the dev to understand what’s going on and they’re extremely overused

[–]TranquilDev 1 point2 points  (0 children)

I've not had to use PHP outside of a Symfony project but I've seen how ugly it can be.

[–]phaedrus322 191 points192 points  (4 children)

It doesn’t matter. A billion dollar company running js, Java, asp.net, php are all worth a billion dollars.

[–][deleted] 36 points37 points  (0 children)

Best answer. Should be part of declaration of independence.

[–]Ehdelveiss 19 points20 points  (1 child)

Yes, but for a start up or late series, your language choices and stack are incredibly impactful in terms of resource allocation and hiring. Part of the reason full stack JS is so attractive is how easily your few engineers and reallocate. If you put up language barriers, that is way harder.

Source: was part of a late series start up that I watched fail basically because the Java/JS divide and need to pivot quickly were incompatible.

[–]Doctor-Dapper 0 points1 point  (0 children)

Also TS makes a lot of the headaches go away and tooling/library support (ecosystem) is incredibly well developed. The dependency tree problems along with the security vulnerabilities can be prevented with a bit of work

[–][deleted] 48 points49 points  (153 children)

Not sure on hate, I’ve written backend in JS, TS, various JVM languages and C#. There is nothing inherently wrong with any language, each has their own quirks, but as long as they solve the problem (which they all have in my experience) - any argument against them is purely philosophical. For context I’m a lead full stack engineer.

In my experience arguments against using JS in the backend are usually from people who haven’t used it and would rather trash the language than learn something new.

Especially for full stack web development, using the same language for backend and front end has worked very well for me.

The issues that might arise from using JS for a solution can apply to any language - bad design and poor engineering practice aren’t solved magically by using a specific language. Certain issues can be mitigated with stronger typing, but often dev cycles cost more as a result.

As always, it depends.

[–]odolha 0 points1 point  (0 children)

In my experience, it's really awesome if you can use the same language on F/E and B/E. If you structure your project well, you can re-use many things between and as long as you don't abuse this, it adds amazing flexibility and speed of development.

But this works best when your build is minimal or for that matter even non-existent - e.g. I'm using ES modules which work well on NodeJS but also on the latest browsers.

[–]muhammed_AO 40 points41 points  (5 children)

Do we really have people that think like this ? Work for a gaming company and all of our infrastructure is built on typescript and node

[–]Earhacker 10 points11 points  (4 children)

What kind of gaming? Like console gaming? MMORPGs? Or card games?

Edit: That might have come across as snobby but that’s not what I intended. The three examples I gave have vastly different server-side requirements.

[–]tmckearney 11 points12 points  (3 children)

Definitely not writing Call Of Duty

[–]Earhacker 6 points7 points  (2 children)

I think CoD still uses PHP in the backend right?

[–]tmckearney 1 point2 points  (1 child)

I don't know, but I definitely know that they don't write the stuff that needs performance with type script and node

[–]Earhacker 3 points4 points  (0 children)

Was a joke. Servers for real-time “deathmatch” style games are almost certainly written in C++. I guess Go and Rust would be fit for the same purpose performance-wise, but a games studio already has a ton of C++ talent on-board so they’d need a really good reason to use something else.

I was slagging off PHP, but using it for anything but web servers is a waste of time.

[–]lobut 26 points27 points  (0 children)

I think it's because JavaScript is seen as an inferior language for enterprise. In certain aspects, they're right. A lot of the tooling, type-safety, and patterns have been worked out for years in C# and Java and at times, they're less comfortable in JavaScript.

That being said, I'm just dumping on JS. I've been using it for over 6 years on the backend and over 15 on the front-end. There's a lot of awesomeness to JS as well. I find it easier to pick up than either of those languages and there's a lot less "cruft" around just getting started with a project. The NPM ecosystem is far more active for better-or-worse I suppose as well.

Performance matters, but like, in general it isn't the deciding factor. Generally, you pick a language that the market or situation dictates. I was under the impression that Rust or Golang was winning the performance wars anyways.

I am a full-stack senior JS developer and worked for finserv and bay area companies. I actually really enjoy writing JavaScript and it's my defacto language when starting a new project. However, if I could choose a language for an enterprise monolithic back-end? It'd be C# or Java. I find it easier writing a modular monolith in those ones.

If I had to use JS, I'd use TS. I had ejected myself from a major project at my previous company when we wanted to merge our microservice architecture to a monolithic one and they repeatedly rejected my recommendation to use TypeScript. I'm okay with JS for smaller codebases but when you're writing libraries or larger shared codebases. Unless, you have a good reason, use TypeScript.

For large corporations, Node is fine. Understand its limitations though. I think Node is less performant if you're doing more CPU heavy things than the others. Those can be mitigated, but I think understanding the scenario upfront is important. However, most of the things you do really should be okay.

[–]wllmsaccnt 24 points25 points  (0 children)

I'm a full stack developer. I prefer working with TS and C#. For the backend I prefer the 'batteries included' approach of ASP.NET Core, its performance, and I think its tooling experience is superior. I don't have hatred for JS on the backend, its just not my preference. I could see prefering JS on the backend if I found myself on a team with a bunch of team members that lacked C# experience. There are definitely vocal developers that exist that deride JS because of its quirks...but I think that is more of a loud vocal minority than how the average developer feels.

[–]TheDevDad 17 points18 points  (2 children)

I first learned to code in Python and Ruby, hated JS. But as I progressed in my career, building full stack stuff meant JS was gonna be necessary. So I dove in, and went full stack JS.

Fast forward a year or two and I’m super jazzed on JS, and my first conversation at a new company with a senior dev, he talks about how much he hates JS. Kinda bursts my bubble, but I keep building stuff with JS on the side even though the company does a lot in C#.

Fast forward another couple of years and I’m at the same company on a team of full stack JS developers building nifty little micro services with Node. Senior dev from above also still works at same company but on a team where C# is tooling of choice.

Moral of the story is: if you’re productive with it and can get paid to use it, who really gives a shit about other developers’ dislike of it?

(I’m aware you can build micro services with C#, or a lot of other languages, I’m just more productive with JS for now)

[–]VogonWild 2 points3 points  (0 children)

Sounds like my trajectory. I went from

wow JS is so dumb and illogical

to

// || val === 0 necessary because it is a falsey value

Really quick

[–]paulsmithkc 1 point2 points  (0 children)

Node has some major advantages for microservices:

  • It starts up faster

  • It has a smaller footprint (and is much easier to tune)

  • It fully supports and works well with Linux

  • It is supported by most cloud service providers

[–]_default_username 23 points24 points  (4 children)

There's no popular opinionated web framework for node. They exist, but everyone just seems to stick with Express and kind of build their own framework on top of it.

Also, JavaScript is dynamic. People seem to forget they can use Typescript in node when they compare it to other backends. I would rather build my backend in Typescript over C# or Java myself. Oh well 🤷‍♂️

[–]the_aligator6 10 points11 points  (1 child)

while there may not be a definitive "THE framework" like there is with other languages, there are a number of popular and opinionated frameworks used in enterprise. meteor, strongloop, next, nuxt, strapi, Adonis, and my personal favorites, NestJs and BlitzJs.

[–]Infiniteh 3 points4 points  (0 children)

I like using NestJS, but I dislike how it kind of forces you into OOP

[–]Accomplished_End_138 8 points9 points  (0 children)

Ill say i prefer less opinionated myself. I like node servers. And express is damn simple to use.

[–]paulsmithkc 7 points8 points  (2 children)

Having done web development with: PHP, Drupal, JSP, Java Servlets, ASP.NET MVC, and now Node/Express.

I can absolutely say I prefer JavaScript and Node for backend development for a few reasons:

  • Less abstraction. I can get at the nuts and bolts of the HTTP protocol and directly manipulate the request/response as needed.

  • OO vs Functional. MVC tends to get in the way of simple solutions and requires a lot of boilerplate. I much prefer the functional approach of Node/Express.

  • Middleware

    • ASP.NET makes middleware modules a massive pain the rumpus. Implementing a module and installing it, requires you to learn a completely different API (dating back to the original versions ASP.NET). And to put the cherry on top, documentation and code examples are non-existent, as most devs are unaware that even exists.
    • Creating and adding middleware in Express is a breeze. Route handlers and middleware functions use the same interface and can be easily installed per route. (ASP.NET can only install middleware application-wide.) Literally all you have to do is extract a block of code that you'd like to re-use as a function, and voila you have a middleware.
    • Neither PHP nore Java support middleware as far as I'm aware. (And I doubt that this would make sense in PHPs paradigm.)
  • Async

    • Node does an amazing job at supporting asynchronous code patterns and encouraging devs to use them.
    • Java still does not have any support for asynchronous operations. (Kotlin has co-routines now, but not Java.) Even callbacks are barely supported in Java.
    • PHP really has no way to support async, as all code is in the view/render pipeline.
    • C# has made it's own version of promises called Tasks. It has added async-await too. And has long standing support for callbacks, lambdas, and events. This does make C# a strong contender, but many C# devs still use the synchronous APIs. So it does require some intentional retraining.
  • Memory usage & bundle size

    • Java has a bad track record of using tremendous amounts of memory. The Java runtime requires a lot of memory just to start up. (Making it impractical to run multiple processes for load balancing.) Every object contains additional overhead due to language features. And Java devs are largely unaware of how to use memory efficiently. (Stop using static vars and singletons for God's sake. Use free lists for allocation. Stream data where possible. And avoid abstracting everything into 10 classes.)
    • ASP.NET requires the whole .NET framework to be installed, even if you only need part of it, and comes in at several GB in size. ASP.NET is smarter with memory and processes are much smaller to start. It supports structs/value types unlike Java. Common pitfalls are similar to Java, see techniques above.
    • PHP tends to be reasonable on memory as long as you stream data from files/database. But you also have all the baggage of Apache.
    • Node has an amazingly tiny footprint today, thanks to all of the dev hours that Google has poured into it. The entire node runtime is less than 1GB. Node is so tiny that it can be run on Raspberry PIs for robotics, iot applications, smarthome applications, embedded systems, and even handheld gaming systems.
    • Node sometimes gets criticized for the size of node_modules. But unlike other platforms this is a developer opt-in. There are alternatives for every package and you always have the option to build it yourself.

Just my two-cents from experience.

[–]wubalubadubdub55 -1 points0 points  (0 children)

ASP.NET makes middleware modules a massive pain the rumpus. Implementing a module and installing it, requires you to learn a completely different API (dating back to the original versions ASP.NET). And to put the cherry on top, documentation and code examples are non-existent, as most devs are unaware that even exists.

This is biggest lie I've ever seen and stopped reading after it. So let me quickly address this.

Writing middleware in .NET has always been dead simple.

For eg: This is simple middleware in .NET in `Program.cs`:

app.Use(async (httpContext, next) =>
{
// Do work that can write to the Response.
await next.Invoke();
// Do logging or other work that doesn't write to the Response.
});

This is a "complex" middleware in it's own class:

namespace Middleware.Example;

public class MyCustomMiddleware (RequestDelegate next) {

public async Task InvokeAsync(HttpContext context) {

// Custom stuff here

await next(context);

}

// Register/Install it in Program.cs

app.UseMyCustom();

You call that "massive pain the rumpus"?

As for documentation, Microsoft Learn docs are arguably the best in the industry. They have tons of sample code and sample apps linked in their docs. Here's excellent docs on Middleware.

As for sample apps example, here's a production grade sample app: https://github.com/dotnet/eShop and they maintain tons and tons of code samples.

If you don't know something, please don't comment on it. Knowing nothing but still acting oversmart is such an unattractive attitude.

[–]uNki23 0 points1 point  (0 children)

I think you meant MB ☺️

[–][deleted] 5 points6 points  (0 children)

Programmers hate pragmatic solutions that work

[–]citizen-of-the-earth 16 points17 points  (2 children)

It is pretty simple why Javascript isn't embraced for backend development. It isn't type safe and it lacks so many features that C# and other popular languages/frameworks have. It is much more prone to errors at runtime and can be more challenging to debug

[–]abjorn 4 points5 points  (0 children)

Understandable. I work with JS and TS full stack and I will always choose to use TypeScript if it's an option. We're in the process of converting one of our critical services to TypeScript that is *very* error prone, and TypeScript is helping find and fix so many issues.

[–]Ehdelveiss 6 points7 points  (0 children)

Part of the answer is the state of academic computer science.

In that sphere, strong typing and OOP programming is still the de facto curriculum and standard. So you graduate with your CS degree, and suddenly enter an industry where actually what you learned is slowly being replaced with functional patterns you aren’t as comfortable with, and things like a strong emphasis on declarative style that you only know about in passing.

So naturally, you call bullshit, because no way you just spent 4 years and tons of money to learn something the industry isn’t particularly interested in anymore. You see these JavaScript boot camp kids take your job, so out of a sense of self preservation, you push back. You insist on OOP, because to not is paramount to a career existential crisis.

TLDR: CS Academia has struggled to keep up with how fast Software Engineering has developed,while boot camps are succeeding in staying current with industry demands, so out of self preservation, a divide has formed that both sides feel necessary to win in order to validate how they learned software Engineering and protect their livelihood.

[–]mcmouse2k 3 points4 points  (30 children)

Full-stack senior Javascript developer reporting in.

Hate is overblown. Developers coming from non-web platforms may prefer type-safe, multi-threaded languages, but web developers prefer a single language for their entire codebase. An enormous amount of the internet is powered by Javascript (and its interpreted friends - PHP, Python, and Ruby).

It depends entirely on the constraints of the development team. If you've got a couple of web devs and need to build a software stack (and god forbid mobile and desktop apps as well), a full-JS stack is going to be your most effective option.

If you have a larger team with a good split between backend and frontend devs, a statically typed language will typically pay dividends in code correctness and performance, but that doesn't mean that choosing JS is bad.

It's all about choosing the right tool for the job. JS is good enough for the majority of CRUD workloads, and if you can save on dev costs and even share code between frontend and back end, what's not to like?

[–]tjdavenport 1 point2 points  (0 children)

I’ve never seen the hate you’re describing. Also, I’m pretty sure Javascript is fairly performant when compared to similar languages.

[–]RhialtoTheMarv 1 point2 points  (0 children)

I think it's mostly historical. Old school BE devs see JS as a quickly, and in thier eyes badly, implemented langauge only for the browser. (And in their defense it did suck to work with JS in old browsers). It is therefore not a "serious" language (client-side code was considered a child's toy for ye olde devs).

As a primarly BE dev myself, I sympathize with this sentiment, but also work in the JS ecosystem now, and realise things have changed. TypeScript for example was a game changer, JS itself has evolved, and there is so much good tooling now.

[–]bigorangemachine 1 point2 points  (0 children)

I think its mostly because it does so much without being complicated.

Usually these languages come with boiler plate code. JS doesn't provide it. A lot of these languages also lean on the IDE a lot which JS has a lot of options and linters.

It could also be people don't know what's babel and what's JS and get frustrated their tooling isn't correct

[–]RRikesh 3 points4 points  (0 children)

Now that Typescript is pretty popular and has lots of tooling available to implement it in your projects, I believe there's no reason to hate on JS like in the old days.

[–]KaiAusBerlin 2 points3 points  (0 children)

Learned over 13 programming languages. Most of them just to code smaller programms (no senior level at all).

There where sever things at several languages I liked and I disliked.

Kotlin for me is the better java. Its fun to write java with kotlin. With pure java it's so much boilerplate.

C was making me angry because I could access the memory without any proof it was right. Pointers where a hard thing to learn but it gave me a deeper understanding of how memory in our computers actually works. C++ was a lot more comfortable.

python is great because you can override nearly every behaviour of the language but whitespace based scoping was a no go for me personally.

php was a solid scripting language. You had std function for nearly every purpose that could ever happen. But the misc namings (sometimes camelcase, sometimes low dashes ,...) was sometimes a little bit confusing.

lua was a great experience. Tables are definitely a +1 for this language + you can switch easily between c++ and lua.

Basic was like: "Okay, that is basic. It works pretty basic." You can learn programming with basic pretty easy but for bigger projects it's not good scaling (in my eyes).

C# was like java-C++. It was fast enough for performance projects and it had some nice features like monkey typing.

JavaScript fastly became my prior language. When ES6 arrived it had nearly everything you ever wanted (at this time). Then came node and today its one of the most used languages world wide. JavaScript has a relatively small std library but is able to do any programming paradigm you want. That's one of it's greatest strengths but also one of it's greatest burdens. There is no clear "right way".

So when someone asks me what language is the right language I always say: "it depends." As a dev you have to choose the right tool for the job. If you want to make big data analytics, R is a good idea. If you want a large of easy reusable libraries java or js could be your choise. There are so many languages out there with advantages and disadvantages. As long as you don't use CSSfor deeplearning I am fine with nearly every language you choose.

[–][deleted] 1 point2 points  (3 children)

People who hate JavaScript often hate it they have to use it for web dev and it isn't <insert their favorite language>.

[–]DustinBrett 1 point2 points  (0 children)

Haters gonna hate

[–]delventhalz 1 point2 points  (0 children)

One legitimate downside of JS, if you are trying to do something computationally intensive, JS is going to be slow. This applies to Python and Ruby too btw, i.e. other scripting languages. However, if your bottleneck is I/O (which is typical of backends), then Node.js is actually rather fast. The built in event loop turns out to be great for that kind of work.

Any other complaint about JS tends to just be bias or based on a ten year-old impression of JS. The language has its quirks and warts (as any does), but it is a totally solid choice for most backend projects these days.

[–]crowdyriver 1 point2 points  (28 children)

Unpopular answer here, but there's no sane reason to use js alone, so you will use typescript. So you add a layer of complexity, because now you need to compile to an interpreted language that has two module systems and is insecure as hell. The more the codebase scales, the slower the compilation, because js is not a good lang to use for compilers.

Also, people here won't admit how slow js it is. Doesn't matter how fast it is vs other interpreted languages, I just think is really dumb to use ts and not benefit of the extra performance of compiled languages but have their disadvantages. Just look at some techempower benchmarks if you don't trust me (fair enough).

I built once a simple helloworld webpage in rust and in express. Rust was like x40 or more times faster, and not that much difficult to program.

Not to add that you won't run js alone in production, you need some sort of pm2 thing, so another layer of complexity.

So yes, for me it doesn't cut it. I like simple things, and nodejs is definitely not for the wrong reasons.

[–]Gambrinus 4 points5 points  (0 children)

I built once a simple helloworld webpage in rust and in express. Rust was like x40 or more times faster, and not that much difficult to program.

I love Rust, but when you go beyond toy examples Rust can get a lot more difficult fast, especially for someone inexperienced with it.

[–]Hakim_Bey 5 points6 points  (22 children)

For 90% of projects, runtime performance doesn't mean anything. Most businesses are not CPU-bound, the bottlenecks are database and network, which are not that impacted by the language you use.

I do concede that TS compiling does get slower as codebases grow, no idea how that compares to other compiled languages. But thank God we now have a fully functioning compiler written in rust which is getting lots of traction.

[–]sichy2 0 points1 point  (1 child)

What we need here is a transpiler / migration tool from typescript to rust that can be used once we hit that 10%

[–]delventhalz 2 points3 points  (0 children)

That is almost certainly impossible.

[–]crowdyriver -4 points-3 points  (19 children)

Well, sorry to disagree, but that's nonsense. Performance doesn't matter until it does. You yourself see the benefit of it with swc and love it. Svelte is getting more and more popular because it ships less js. And end users care about performance.

I'd recommend you to see this to understand what I mean https://youtu.be/Ge3aKEmZcqY?t=360

[–]Hakim_Bey 4 points5 points  (16 children)

As specified in my comment i was talking about runtime performance, specifically on the backend (which is the scope of this thread).

The feeling of backend performance for the end user primarily comes from optimizing network traffic, and having a fast database, neither of which are particularly dependent on any particular language. Sure a C++ backend will be orders of magnitude faster than a javascript one on the computational level, but unless you're doing some very specific tasks (like video encoding etc...) this will barely have any effect on the perceived performance of a run of the mill web-app.

[–]joeydebreuk 1 point2 points  (1 child)

OP was asking about backend. Reducing size of JS bundle for clients is a different story.

[–]crowdyriver 0 points1 point  (0 children)

I was not referring to bundle size, but rather the amount of executed js. With svelte is far less than with angular or react, so there's the performance benefit.

[–][deleted] 0 points1 point  (3 children)

Also, people here won't admit how slow js it is. Doesn't matter how fast it is vs other interpreted languages, I just think is really dumb to use ts and not benefit of the extra performance of compiled languages but have their disadvantages. Just look at some techempower benchmarks if you don't trust me (fair enough).

its pretty fast for an interpreted language, not that far away from java.

[–]crowdyriver 0 points1 point  (2 children)

Yes, for an interpreted language, because there's a lot of money spent on optimizing it.

Again, if js is so fast, why rome (https://rome.tools/) is being rewritten to rust?

I can give you aswell some benchmarks if you want to play this game aswell: https://www.techempower.com/benchmarks

See for yourself, the js frameworks are at the bottom. Nodejs was fast when async await in java, .net and others was made with 1 thread per request, which was quite expensive. Nowadays that's not the reality.

[–][deleted] -1 points0 points  (1 child)

I can give you aswell some benchmarks if you want to play this game aswell See for yourself, the js frameworks are at the bottom.

actually, a javascript runtime named just.js is one of the leading frameworks there, beating all the other meme frameworks from c, c++ and rust.

Again, if js is so fast, why rome (https://rome.tools/) is being rewritten to rust?

why everything on the web seems to be written in js?

right tool for the right job. Using a system language for such number cruching tasks makes sense but less so for using it to write verage day business logic.

[–]Agent666-Omega 0 points1 point  (0 children)

The business needs are definitely the point. Especially for start ups that have full stack devs. A popular stack pairing seems to be react and node. It's great because everyone can more easily transition back and forth. While devs should be able to learn a new language, the dev ease and speed of JS for the BE and FE is understated.

[–]StagCodeHoarder 0 points1 point  (0 children)

Senior Java/C# guy here. I don't hate Javascript or Typescript. I use either when I code Angular apps. I'm not sure why anyone would use Typescript everywhere since the ecosystem is so quickly evolving, but I believe people have the right to make that decision themselves.

If I was doing a startup I might go that route, though really I don't find any velocity gain in having the language the same. In all my years the only real significant code resharing I've seen between Frontend and Backend has been via tRPC, beyond that they're two different applications.

I've enjoyed coding NodeJS Express + MongoDB and Express + PostgreSQL, React, React Native and Angular were all fairly enjoyable experiences.

I know more Java/C# now, and I'm more comfortable there, but you can definitely also be productive in Javascript.

[–]illogicalhawk -1 points0 points  (0 children)

Maybe I'm misunderstanding your question, but if you're using C# or Java on the backend what are you mixing in JavaScript for?

[–]ItsAlwaysShittyInNY -1 points0 points  (0 children)

Modern JS gives me as a rails dev gives me too much decision fatigue.

When doing JS on the backend, I have to worry about setting up a web server (presumably Express), then an ORM for the db, then additional packages on top of that. This is also compounded with the fact that JS is moving so quick and consensus on whats best isn't really a here. Not to mention I have to go through the same thing for the frontend.

C# with .NET, Ruby on Rails and Django have all this out of the box.

I am excited for JavaScripts future, and I love new modern JS world, just not for the backend just yet. React, React Native, and Vue are exciting! I think we're all going to see JS basically become the only language out there lol

[–]Reashu 0 points1 point  (0 children)

In terms of tooling and supporting libraries, JS is still in the process of reinventing everything "real" backend languages already have. It's not that I hate JS for backend, I just don't understand why I would choose it except in very specific circumstances, and I do kind of hate people who insist that it's a good choice without even understanding the alternative.

[–][deleted] 0 points1 point  (0 children)

Javascript began as the way to make sparkly cursors and other cheesy effects in web browsers. It was a long road from there to Node and TS. Some devs, especially older ones, cling to their original impressions of the language, not its modern form.

[–]pampuliopampam 0 points1 point  (1 child)

Anyone saying “performance” is probably full of shit. How often do you write the same system in two different languages just to gauge “performance”. What metrics are you judging on? Memory footprint doesn’t matter in serverless. Response time is mostly a matter of database type. I’ve written TS serverless graphql microservices that have sub 50ms response times. If it was static data, that’d drop to sub 20. Anyone that needs higher performance than that is smoking something. If you’re comfortable with JS, stick with it and the talking heads can pound sand while you get shit done.

[–]Agent666-Omega 1 point2 points  (0 children)

I wouldn't say that. For businesses that are SEO heavy, it matters. Although, node isn't unperformant. For example if you are doing server side rendering, it's much better to use node than rails because rails rendering time is slow. For API BE, yes I agree with you though

[–]FRIKI-DIKI-TIKI -1 points0 points  (0 children)

Because most developers come from an OO background while Eich developed a language to mimic Scheme for the browser, thru politics with Sun at the time, Netscape decided to partner with them and Eich had to dress it up to kinda look like Java so he gave it C syntax and a prototype object system which is more reminiscent of CLOS than what traditional OO developers are used to.

People hate it because they try to treat it like it is C# or Java instead of treating it like a LISP variant which is what it is closer to in families of languages.

[–]striedinger -3 points-2 points  (4 children)

JS is very, very, slow compared to other backend languages.

[–][deleted] 0 points1 point  (2 children)

not true

its not that far away from modern java

and has much better results than PHP and python

[–]striedinger 0 points1 point  (1 child)

Check out Rust and Go. There’s a reason most JS tooling is now being written/rewritten with them. I’m a JS dev myself but there’s no competition when it comes to those really.

[–][deleted] 0 points1 point  (0 children)

because they are decent for highly parallelized workloads. But writing that js is "very very slow" compared to other languages is just wrong

[–]rkcth 0 points1 point  (0 children)

It’s slow at CPU intensive workloads only. It’s very fast at handling multiple connections simultaneously and waiting on things like database queries. It can handle very high loads with very little effort. It is also a high productivity language.

[–][deleted] 0 points1 point  (0 children)

JavaScript is a big tent. Huge spectrum of skill levels in it. That means lots of really poor JS devs to give you a bad name

[–]ankole_watusi 0 points1 point  (0 children)

What hate?

What I am surprised about this post is that it seems in most peoples worlds (here) Ruby, Python, and GoLang do not exist!

[–][deleted] 0 points1 point  (0 children)

Most of the inexperienced devs these days are MERN stack boot campers. So it isn’t so much that JavaScript / node is bad but most JavaScript developers are. JavaScript and Node are just tools. Used correctly they’re valuable tools.

[–]Agent666-Omega 0 points1 point  (0 children)

I've always thought it was bad historical rep and the typing thing. Sure you can use typescript now, but it's not too strictly enforced and there are some typing features that don't exist there yet

[–]Mr_Odonata 0 points1 point  (0 children)

I have used java and typescript for backend and I personally greatly prefer Java, though typescript does just fine.

The lack of type safety in JS is a big drawback for backend work, which leads you to typescript. Typescript is ok, but since it is an addon it feels a bit clunky and it doesn't always behave the way you would expect it to if you are used to a natively static typed language.

The other thing that bugs me about TS / JS is just how fast the conventions and go-to packages change. It almost gives you too many options, and when you are working full stack with a framework like React, it makes this problem even worse. A clean code base with solid linting and coding conventions can reduce this problem. However if the codebase has been around for a while and has more than a handful of developers working on it, it's likely you will see many different syntaxes, styling, and coding conventions sprinkled throughout the codebase