That goes away with experience. Typescript can be particularly bad because it has in incredibly complicated type system (to accommodate all the wacky things you can do in JS), but after you get "used to it", the puzzled pauses become fewer and fewer. Eventually it's no inhibition whatsoever, and actually makes you faster because of IDE code completion, refactoring, and bugs caught by the IDE/compiler.
This is that "blub" thing people talk about.
> Try vanilla Node/JS if you want a faster Rails.
Understanding now that you meant development velocity (or whichever term), I contest that static typing is in impediment in general, but rather that it's an impediment for people who aren't used to it. Especially for those who don't care if their code is correct or if it only appears to be correct superficially, although someone will inevitably (and authoritatively) drag out some decades-old study which finds no significant benefit to static typing when comparing Python/Lisp to C++89/Java or something.
Types are like living documentation - a contract between devs that describes and enforces specific behavior. Just because you know what properties an object contains now doesn't mean you'll remember it in a month, or that the dev who inherits your work will have an easy time figuring it out. I feel way faster when I code using types, because the type system tells me exactly what I'm working with at a given time. This ends up preventing lots of bugs and makes debugging errors that do happen way easier, in my experience.
So TL;DR types seem slower at first but the dividends are paid in full, and then some, when you have to maintain a project among many devs or teams of devs.
EDIT: not to mention that IDE autocomplete features often seem like a superpower when working with static types. I'd recommend Typescript for that reason alone, honestly.
[Access to this page may require you to create an account.]
For years, IEEE has ranked the top 55 languages based on five use cases typical of IEEE members: overall, web, enterprise, mobile, and embedded, and ranked three ways: trending overall, in demand for jobs, and used by open source.
The 2020 results, ranked overall:
1 Python 100.0
2 Java 95.3
3 C 94.6
4 C++ 87.0
5 JavaScript 79.5
6 R 78.6
7 Arduino 73.2
8 Go 73.1
9 Swift 70.5
10 Matlab 68.4
11 Ruby 66.8
12 Dart 65.6
13 SQL 64.6
14 PHP 63.8
15 Assembly 63.7
16 Scala 63.5
17 HTML 61.4
18 Kotlin 57.8
19 Julia 56.0
20 Rust 55.6
21 Shell 52.0
22 Processing 49.2
23 C# 48.1
24 SAS 45.2
25 Fortran 43.0
26 Cuda 41.0
27 Visual Basic 40.3
28 Objective-C 38.9
29 Delphi 38.6
30 Perl 38.2
31 Verilog 37.6
32 VHDL 36.7
33 LabView 36.7
34 Elixir 35.8
35 F# 34.7
36 Prolog 34.6
37 Lua 34.4
38 Lisp 33.0
39 Ada 32.8
40 Apache Groovy 32.0
41 Scheme 31.4
42 Haskell 30.8
43 Cobol 30.4
44 Clojure 29.8
45 ABAP 29.5
46 D 27.7
47 Forth 23.7
48 Ocaml 23.7
49 TCL 22.1
50 LadderLogic 19.5
51 Erlang 18.3
52 Eiffel 16.5
53 CoffeeScript 15.9
54 J 14.3
55 Racket 0.0
* Pre-confugured prod/dev/test environments
* Preconfigured webpack for the environments above
* DB migrations
* telemetry/metrics with live dashboard
etc
P.S. encrypted signed cookies, changesets (validations for db models or arbitrary forms), clustering, websocket stuff, "liveview" serverside rendering ...
That said, I've seen that "liveview" thing demoed and that is definitely pretty slick. Off topic but it's very similar to a package I implemented in Django like 6 years ago or so (and happened to name it the exact same thing, too) --- sadly was for work in a proprietary setting, although I'm off-and-on working on remaking it now for a different project where I can open source it.
I haven't tried Spring Boot, so I can't speak to that, but gather that a lot of people like it. Otherwise, though, it's kind of a mess of too @#$% many options and no clear winner aside from the legacy stuff that nobody actually enjoys working with on the flagship language, an alternative language that was initially promising for web development but ultimately collapsed under the weight of its own creeping featuritis, an alternative language that collapsed under the weight of efforts to turn it into Jonathan Livingston Programming Language, an alternative language that collapsed under the weight of a cult of personality, and an alternative language that looks poised to collapse under the weight of Oracle v. Google.
I too find it annoying that everything feels like early 00s as it prevents uptake; I think most can be fixed by creating a new, modern website for the project, adding examples how to interact with the system with modern tools and a 'try it out in your browser'. Many Apache projects, for instance, are great and very robust in the current time, however, when you go there to do research on what to use for a new project, the examples start with XML files and then Java classes. No matter what I think of node, examples these days must include a little few-liner with node, python, go, curl, java, clojure, ... . Most people like the idea of java -jar somethinggreat.jar, but opening IntelliJ, adding all kinds of arcane (when you are used to Go, Node, etc) artifacts and then writing actual Java code which you did not want to do in the first place, really hurts adoption imho. And made many projects not even appear on anyone's radar.
Like (anecdotally) picking mongo for a (trading) case geode was basically made for, but mongo was hip, not 'old apache' and not 'old java'.
The declining interest in Java is offset by Kotlin, Scala, and Clojure.
Did the Dart guys somehow gain massive momentum? Or is Electron or React eating this up?
I dismissed everything else pretty quickly for being too limited in what platforms I could target. Kotlin's out for being a poor choice for iOS. Dart/Flutter is out for not yet having fully baked desktop support.
The performance lacks somewhat and the debugging tools are not as mature as JVM's. But the libraries, frameworks, and overall development productivity are great.
Not only better library ecosystem, more performance and tooling.
To say nothing of trying to get patches into the core. Be prepared to wait months for any response at all, every time getting the feedback that there is some new minor problem (or even worse, a "this needs to be talked about" without any followup).
It's not a healthy ecosystem. For that you require high-quality core libs, a strong developer ecosystem (that doesn't mean a lot of devs, it means good ones) and a culture of third-party libraries being few but high-quality. Anything else is going to end up pissing you off, guaranteed.
The original project I was discussing ended up going with Kotlin on the server, and everyone (including devs) are super happy with it.
I program in Node/JS currently and programmed in Java about 10 years ago. But my preferred language will always be Ruby. I will never understand why "the community" (ML, scripting etc) preferred Python to Ruby.
Do keep in mind that one of the reasons people choose Python though, is exactly because it is used in a few different domains. E.g. I'd rather my server-side language be the same as my video-processing language be the same as my data-science language, it makes things easier.
Here are some stats that you could and should take with a grain of salt: https://w3techs.com/technologies/overview/programming_langua...
My anecdata also says neither Django nor Flask are very populate. I have yet to encounter either one already in use by a client. Rails is also rare. I think scrappy startup frameworks are a different population than what most devs (who work at big firms) use.
Python is certainly #1 in ML, for example, but far from #1 in web.
I had a "which stack" argument with a client recently for a web server processing tons of data. He wanted to use Node (which I hate, but also use when performance doesn't matter because TypeScript is so good).
I showed him that the Node library ecosystem is actually pretty weak (many libraries, but most abandoned, single-contributor, and/or low-quality). Of course, browser libs for JS are amazing.
My point is just that mixing all these things together in popularity rankings is pretty meaningless.