However, I think that is good to recognize the good things too:
- JS function and object notation is very flexible and nice to work with. Each time that I go back to Java I feel the pain.
- PHP makes JS look nice and consistent by comparison (note I used PHP from v3 to v5... so my comment maybe wrong today)
- Adopting functional constructs for some parts of the std lib was good. Many times I wished to have an equivalent map/filter/reduce in Python (the list comprehension syntax is terrible)
- NPM and small modules receives tons of criticism. But it allowed NodeJs to thrive. Anybody can publish or get a lib with one command. By comparison doing the same for Java was really hard in the past (you needed permission to publish to MavenCentral... and if you were lucky you were allowed after many days of mail exchanges). The situation in other languages is not better: Python package management is a mess of options, Swift package management is not mature enough.
- JS doesn’t have threads... but some languages (eg Dart) moved away from the classic threads constructs to adopt actors. If you did anything with mid complexity using Java threads and dealing with synchronized/wait you start to appreciate the simplicity of async / await.
- Template literals existed in many languages (shell scripting, Perl, etc). But in JS they can be easily extended with template functions.
- I prefer any of the Node web server frameworks over the pain of Java (I worked for many years using servlets, JEE, Spring.. and Java Rest API frameworks).
I’m not trying to do a “what aboutism” argument, just highlighting that besides the limitations there are also good design decisions in the JS ecosystem.
Java cruft is better these days if you use 11+ with Lombok. Almost decent. You can also use Kotlin which is honestly good, but unless you pay up for IntelliJ support for it is mediocre at best. I really like Typescript's nominal typing, wish Java chose that road.
I'm not a Python guy, but Java has Streams and RxJava which is great for functional stuff. I'm pretty sure RxJS was originally a JS port of RxJava. The same library has flavors in most languages now, you may be interested in the Python version https://github.com/ReactiveX/RxPY
Publishing to NPM registry is much easier, but everything else is worse. I blame much of it on the lacking standard library. But JS not packaging libraries in archives, plus using minifaction instead of a bytecode format both suck. JS has a huge parsing problem, for some sites half the page load time is parsing JS. VM's with an efficient code representation like C# and Java avoid this. Java and C# package source, compiled code, and documentation in a standardized (and efficient) way. NPM just isn't there yet.
Java is missing async await, but there's also grumbles about supporting it and function coloring. Java has Akka, promises (CompletableFuture), parallel streaming, and traditional threads. The problem with supporting async/await without threads is that it doesn't solve for modern CPU's having more and more cores. In Java/C# its trivial to use the whole machine and share structures.
You should try Vert.X, its very similar to Express. I would almost dare say Express borrowed a lot from it.
There's some good design decisions rolling in, but still plenty of reasons I avoid it when I can.
I still write both JScript (for WSH) and VBA (for my sins?) and I much prefer JScript. At least it lets you easily create your own abstractions thanks to anonymous functions, whereas VBA really fights you at every turn in this respect.
1. it needs buy in from all the browsers or it might as well be useless
2. browsers need to bend over backwards to be backwards compatible so that you can run old web pages. if a browser does not work on all the web pages a consumer needs they will simply not use it.
3. I would bet good money that most of the management in charge of the websites that make up the web would not waste dev time on migrating to some minified JS file replacement, when webpack-style minifying works "just fine" and allows your team or whatever to keep churning out new features
I don't think so personally. Code size is a huge issue for page performance, and a "bytecode" format would probably be 2-3X smaller and 2-3X faster to parse. Together, this might triple JS loading speed. Maybe double the loading speed of JS heavy sites.
JS with sourcemaps isn't so different from compiled code with debug symbols. The sourcemap support could probably be adapted with minimal work. And its likely the transition would be transparent to most users, nobody really looks at the minified JS as it is.
Another big advantage is vastly simplifying JS parsing and JIT compilation. In Java and C#, most features are added without changing the code format. And when it does get updated changes tend to be minimal. Upgrading browsers and minifiers every time JS adds a language feature is a real burden on the ecosystem
The worst parts of the web do not prioritize latency numbers, so I don't see how you'd convince them that it's worth it, and any backwards-incompatible changes to the web (to force them to make the change) have historically had poor uptake from consumers, devs, and browsers alike.
I've been using JS since the JScript days, and let me tell you it was horrible. Awful. I would rather use VBA, Perl, early PHP, really anything I've touched besides COBOL. It was buggy, horrifically slow, had an even worse standard library than it does now, didn't work the same way between anything. I remember testing performance and getting 1000 integer increments a second in an empty for loop. Even back then an alarm clock running C was orders of magnitude faster.
But the massive popularity of the web has made it decent. Its a good example of the (overused) axiom that you can pour enough money into anything and make it good. With JS, this actually happened. Probably because the other choice was transitioning the web to Flash, Silverlight, and Java Applets. The proprietary solutions lost the battle thankfully, even though admittedly they were better than JS for a long time after they died.
There's still lingering problems, some which may prove un-fixable. The standard library is a joke. The 1 million line ancient Java monolith at work pulls in less libraries, by count and space then create-react-app. And not having threads is just terrible. People that don't know better ape over async, not knowing that most languages have async, threads, sometimes fibers, and fast shared memory between them. And NPM works decently but putting 5 million files into my node_modules folder is absurd. NPM is the only reason I know that most OS'es still have a path length limit. You would think the world could standardize on putting libraries into a zip or something like even ancient crufty languages like Java do. If it wasn't for SSD's modern JS wouldn't even be usable. And can we just compile JS already? Minification seems so normal that everyone's forgotten its a shitty hack. If you're going to minify to the point that JS resembles bytecode why not just standardize a format. People say "JS runs right away because its not compiled"... Well... How long does your WebPack take to transmogrify 150MB of spaghettified JS into a pile of chunks you can actually feed a web browser in prod? Probably longer than it takes most languages to compile. If we just compiled to a reasonable format like other VM languages, we wouldn't waste so much time parsing and keeping these tools working with every semantics update.
Here's to the hope that money poured into JS will finally fix the remaining issues. I give it another ten years and I'll finally enjoy most of my time in JS land.