There's a recently-concluded series of four articles collectively titled "
**The Philosophies Of Software Languages** " :
* Foundations, 1940 to 1972, [From Plankalkül to
C](https://www.welcometothejungle.co/fr/articles/philosophies-software-languages)
(includes Fortran, Cobol, Algol, Simula, BCPL/C)
* Revolution, 1972 to 1991, [From Smalltalk to
Perl](https://www.welcometothejungle.co/fr/articles/philosophies-programming-languages)
(includes C++, ObjC, Haskell)
* Evolution, 1991 to 2000, [From Java to
JavaScript](https://www.welcometothejungle.co/fr/articles/philosophies-software-languages-javascript)
(includes Python and Ruby)
* Divergence, 2000 to _now_ , [From Go to
Elixir](https://www.welcometothejungle.co/fr/articles/languages-software-go-elixir)"
(includes Rust and Kotlin)
It's understandable that it doesn't mention Nim, because its popularity metrics
are still far below those languages, although they are growing quickly.
Of course any such analysis is an over-simplification. There aren't distinct
eras and many different trends happening at once. But it's still a worthy topic
of discussion.
It's interesting to speculate how Nim can fit into that narrative if/when it
gains popularity several years from now, and how the next major "era" of
programming language design can be surmised.
Some ideas:
* **Ubiquity of tooling.** Like I said [in another
thread](https://forum.nim-lang.org/t/4770#29838), Nim makes trade-offs that
benefit developer writing convenience over the strict consistency and
explicitness found in languages like Ada, Java, Go, and even Python. Human
beings write code. Computers read code. Computer time is _much_ cheaper.
Computers can then reformat the code to be as explicit and readable as desired.
The IDE (or a Web code view widget) can give you all the insight into the code
that the most explicit language can give, but without cluttering you with
obvious bureaucratic red tape when you don't want it. The ability to read code
on dead tree pulp is no longer a priority.
* **Ubiquity of execution.** Make an app that can run in several modes with a
single codebase: do most of the work on the Web server, or run serverless
inside the Web browser (ex. IPFS, WebAssembly), or in a desktop app, or a
mobile app (ex. [nimx](https://github.com/yglukhov/nimx)), etc. Languages like
Kotlin and Haxe can target more VMs directly, but Nim is definitely a
contender, and smaller binary sizes than Rust could make it a better choice for
WebAssembly.
* **Ubiquity of DSLs**... (I might add more ideas later.)