I would love to hear your suggestions and maybe a short reasoning on why this language is especially interesting. Thanks!
It's not a new language, but it is in its infancy timeline similar to Ruby before it blew up. It needs its own killer app like Ruby had Rails.
High-performance garbage-collected language Compiles to C, C++ or JavaScript Produces dependency-free binaries Runs on Windows, macOS, Linux, and more
I like how it compiles tiny binaries for all platforms with a single command. It's pretty creisi.
I wrote some quite complex things in it to try it out a long time ago when it had strange bugs; I have not tried it since.
Rust has a similar execution speed to C, but has memory safety. It’s able to accomplish this by having a thorough compile time type check, i.e. a lot is checked at compile time so you can still get extremely fast execution speeds.
Another very different recommendation is Clojure, which is a Lisp based on the JVM. You get all Java libraries, plus an amazing functional language that is very elegant to write code with. Plus Lisp will change the way you think about object oriented programming big time.
Elixir seems interesting since it’s functional and runs on the Erlang VM.
Zig (https://ziglang.org) and Lobster (https://github.com/aardappel/lobster) are also pretty interesting!
Crystal is a programming language with the following goals:
* Have a syntax similar to Ruby (but compatibility with it is not a goal).
* Be statically type-checked, but without having to specify the type of variables or method arguments.
* Be able to call C code by writing bindings to it in Crystal.
* Have compile-time evaluation and generation of code, to avoid boilerplate code.
* Compile to efficient native code.
IMO It's the next hacker's language of choice.
I’ve been doing more Emacs Lisp as of late and I wanted a change of pace. It seemed a natural fit to learn in a similar ecosystem. Emacs Lisp isn’t recent but GNU Guile is.
Racket is more batteries included, and comes with an IDE, a package manager and build tools. It self describes a a language creation platform and includes a typed language, a prolog like language and several learning languages, used in their book How To Design Programs.
I’ve used Racket at home and work and enjoy using it, but I prefer traditional Lisp syntax.
TXR is liberally licensed: almost everything is two-claused BSD. (The installer-packaged Windows port uses a Cygwin-derived run-time library that is LGPL.)
TXR builds easily, requiring few dependencies, and has a small footprint.
It's easy to deploy. The TXR executable finds its satellite files relative to its own location: drop it anywhere and it runs. The Windows version uses an NSIS installer, which you can hack to package your own application.
TXR is packed with features. In addition to the unique, original whole-document pattern matching/extraction language it contains an original Lisp dialect that is designed with succinctness in mind. It draws influences from many sources and embodies original Lisp research work.
TXR has a thorough reference manual consisting of one man page which is over 680 pages long (in PDF form). The HTML version is decently hyper-linked for navigation and features a collapsible, tree-structured table of contents.
TXR Lisp is interpreted or compiled; the compiler is written in TXR Lisp, targetting a register-based virtual machine which uses Algol-like displays for lexical environments (dynamically relocated from stack to heap when closures are created). Files can be compiled, or individual functions or top-level forms. Functionality is provided to create a copy of the TXR executable with a built-in custom start-up hook, for application deployment.
I really liked going through https://github.com/janestreet/learn-ocaml-workshop (currently working on the frogger :)
Ocaml is a nice and reasonably simple language, especially if you dabbled with statically typed functional languages. The type-system is not as strong as Haskells, i.e. there are no type-classes, but there is meta-programming support, that provides some of the quality-of-life enhancements stronger type system might (i.e. you often use macros for comparisons, or deriving boilerplate functions)
I would probably stick with JaneStreet ecosystem, the language on its own doesn't have standard library.
There is a support for calling C functions, but haven't tried yet, and documentation seems sketchy.
Almost like Haskell but without pragmas and generally less magic, as it is eagerly evaluated. It compiles to JS and has easy interop with any JS package. Also, PureScript by Example is a really fun book to follow in order to dip your toes in this language.
If you want to rty it out there is even a web-based playground: http://try.purescript.org/?session=c9e5f851-4207-8c8b-d58e-c...
Never used https://github.com/andyarvanitis/purescript-native, but this might be an option if you want to interface with C code. Purescript is built to compile into target language, and even though the JS is the main target there are other forks such as the purescript-native producing C++11, and I know there is backend for i.e Erlang