
Ask HN: Which Recent Programming Languages Do You Recommend to Have a Look At? - fileeditview
I would love to spend&#x2F;waste some free time toying around with a new programming language. I am mostly interested in statically typed languages with a good support for calling C functions. However I am open to everything.<p>I would love to hear your suggestions and maybe a short reasoning on why this language is especially interesting. Thanks!
======
sergiotapia
Nim.

[https://nim-lang.org/](https://nim-lang.org/)

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.

~~~
zevv
Can't recommend this enough: Nim is a very low-friction language with
performance in the C/C++ range, also offers introspection and metaprogramming
with a very powerful macro system.

~~~
partisan
Agreed. I like Nim for game programming. It is much productive than
programming in C/C++.

------
elamje
I just started looking at Rust and I’m extremely excited about it so far.
Knowing the struggles of C, as I’m sure you do, you will appreciate the
abstractions for memory safety.

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.

------
bendmorris
Shameless plug: Kit ([https://www.kitlang.org](https://www.kitlang.org)), a
statically typed language with no runtime, can interface with C without
bindings (by directly including C headers.) Kit includes features such as
traits, term rewriting, algebraic data types and procedural macros, which make
it more expressive than C without all the boilerplate.

Zig ([https://ziglang.org](https://ziglang.org)) and Lobster
([https://github.com/aardappel/lobster](https://github.com/aardappel/lobster))
are also pretty interesting!

~~~
fileeditview
Hey thanks for mentioning! This is why I asked. I knew Zig and Lobster already
but didn't hear about Kit so far. I will have a look. These are exactly the
type of languages I am interested in.

------
thecupisblue
I'd suggest taking a dip into crystal - I've been tracking it's development
and it could be my next general purpose language, it's what you're looking for
too I believe - to quote the docs:

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.

[https://crystal-lang.org/](https://crystal-lang.org/)

IMO It's the next hacker's language of choice.

~~~
sergiotapia
It's a nonstarter because it flat out cannot compile projects beyond a certain
size.

~~~
ktkization
Up to what size specifically?

------
decasteve
GNU Guile

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.

[https://www.gnu.org/software/guile/](https://www.gnu.org/software/guile/)

~~~
fileeditview
From time to time I play around with Racket. Do you have experience with both?
Can you compare?

~~~
cjallen88
Guile is a traditional scheme, its niche being scripting and extension of
existing programs.

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.

------
kazinator
Plug: TXR: [http://www.nongnu.org/txr](http://www.nongnu.org/txr)

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.

------
a-saleh
Recent or just non-mainstream?

I really liked going through [https://github.com/janestreet/learn-ocaml-
workshop](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.

------
jxub
PureScript.

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.

~~~
a-saleh
I really liked to dabble in Purescript :)

If you want to rty it out there is even a web-based playground:
[http://try.purescript.org/?session=c9e5f851-4207-8c8b-d58e-c...](http://try.purescript.org/?session=c9e5f851-4207-8c8b-d58e-c46ad120ae1f)

Never used [https://github.com/andyarvanitis/purescript-
native](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

------
infiniteseeker
Elm, Elixir, Nim (no particular order, choose 1 based on interests etc)

------
whb07
F# or Rust! The former is never talked about, but from the little I’ve seen it
definitely looks interesting. And well, Rust, because...Rust.

~~~
tluyben2
F# is not recent but it is much undervalued; very powerful because of the ML
heritage but more so because of the .NET ecosystem.

~~~
whb07
I’d argue it is recent as most people have never even heard of it. That and
the just recently ironed kinks of running .NET on *nix systems.

------
verdverm
Golang

~~~
fileeditview
Thanks for the suggestion. Go is actually what I write at my day job for a few
years now. I like it and also use it for hobby projects but I would also like
to toy around with something new.

------
henryscala
I would recommend vlang and inko.

~~~
planetis
Yeah, I also like programming in Jai.

------
genuinebyte
Rust

------
Haitischmock
Rust, Julia, Nim

------
juststeve
Rust or Kotlin

