Interesting Programming Languages | Hacker News Reader

Interesting Programming Languages

btbytes.com

229 pointsandrenth82 comments

Notably missing:

APL (Dyalog), J, Prolog, Rebol (Red is on the list), PicoLisp, Racket, Factor, 8th (Reva was mentioned and that was the creator's prior project), and Haskell.

Maybe most of the above are too mainstream for the list.

I'm the author. You are right. I think the above are all "mainstream" enough for me.

At the least, I've installed and played with them all at one time.

You know you're on Hacker News when a language like Prolog is considered to be too mainstream :-).

Great list, thanks!

Too mainstream? Then have a look at T3X (http://t3x.org/t3x) or mLite (http://t3x.org/mlite) or Klong (http://t3x.org/klong). :)

I've been meaning to check out Klong for ages and the accompanying book. Thanks for doing this work Niles!

Picolisp being considered mainstream in any capacity is a pleasant surprise. Might I suggest two more Lisps that I use: Carp and TXR? I also like Picat as an evolution of Prolog.

I guess we need to distinguish between mainstream and HN mainstream haha.

I like PicoLisp and wish it was more popular. There are some decent resources on it and the mailing list is pretty active.

I kinda disagree with the primary author's "need for speed" article on why performance doesn't matter anymore. I think there is definitely the majority of common uses in the business where he is right, but we're getting to a point (think data science) where faster is better and necessary. Using C++ is still too painful for most (pointers anyone), so I'm betting languages like Nim, Rust, and D will continue to grow in popularity to some degree.

I would have included Picat and Kitten. Picat is a descendant of Prolog that has some rather nice differences in semantics. Kitten is a statically-typed concatenative language.

I've talked with the author of kitten before and he's responded before when it was put on HN. I haven't looked at it in awhile, but I do like the concept.

I've read a little on Picat.

Would you say that people interested in languages should first look at certain "mainstream" languages Scheme/Racket, Common Lisp, Haskell, OCaml, Smalltalk, and Prolog, before looking at less-mainstream ones?

Lol nope, not gatekeeping programming languages :)

The above are all pretty cool though and each (as Larry Wall would put it) are the perfect examples of modernism. Each one takes a single idea to a fault.

Lisp => lists, Haskell => functions, Scheme => lists and recursion, Prolog => logic, Smalltalk => objects, Forth => concatenative and extreme minimalism, and APL => arrays.

Most post-modern languages combine many of the above in more practical and less elegant ways. Python is OO at heart, but can be written in a functional style, and can do array programming with Numpy.

So there is value (I think) to looking back at those languages from an educational point of view even if you're not using them in your personal projects or production.

The more novel ones that the author posted are probably also educational in their own way, but probably don't ram just one idea home. I think we're mostly past that now as Wall has stated. Perl6 might not run very fast or be very mature or popular, but it is a very interesting language that does a good job showing the post modern system. It pulls what the language designers felt were the best features from all the past languages (Perl5, Python, APL, Haskell, Smalltalk, Awk, Java, C#...etc).

That list of "modernism" languages has some bits of truth to it, but I think it's misleading to people who aren't already familiar with those languages, and "to a fault" sounds dismissive, and maybe discourages people from learning for themselves.

Perl is an interesting language (and I defended Perl's merits in a language forum within the last year [1]). But people who've mostly done Perl for a long time might want to question cute sayings about other languages, and discover that, today, for example, the evolution of Scheme (especially Racket) has different ways of doing those best features from other languages that you list for Perl6.

[1] https://www.mail-archive.com/racket-users@googlegroups.com/m...

I do think "to a fault" is subjective, but things like Prolog make a great example. Prolog is really cool and useful, but it makes anything except for the queries a real nightmare and will therefore never takeoff as a general purpose language. That's all I'm trying to say. Languages like Perl allow you to do logic programming with logic programming libraries, but also make text processing a breeze.

Take it with a grain of salt of course. Smalltalk is amazing, but the way you store code in an image isn't for s everyone.

I don't understand your last paragraph...can you please elaborate? What cute sayings are you referring to?

I meant the cute saying about modernism and "to a fault".

I agree about Prolog being logic-only. (Though it was once included as the query language of the complex data model of a commercial CAD-like system I worked on.)

Now Scheme (not lists and recursion to a fault) and other languages have logic programming as library or language extension: https://en.wikipedia.org/wiki/MiniKanren

Incidentally, I don't want to sound dismissmive Prolog. It's worth learning a bit, such as with now-free books like: https://mitpress.mit.edu/books/art-prolog

Hey, I like your list. Now, tell us, from that list, is there a favourite language? Some you'd pick up to write simple tools for your own personal usage...

nim/zig/red.

* I already use nim and I'm very productive in it. * Would like to use Zig for "system programming" when and if something like Nim (and D) are inadequate. * Red because its a REBOL and it can be a mind blowing experience to read some clever REBOL/Red code.

Is mainstream just measured by popularity? Ballerina has a pretty mainstream syntax, but I guess it's not well known enough.

Ah that makes sense then, and I have no issue with the list. I learned of a few new ones to try too!

> Maybe most of the above are too mainstream for the list.

While an interesting language may be obscure, an obscure language is not necessarily interesting. In many cases, being relatively well known is a benefit simply because it offers more exposure to new ideas.

I have found languages such as Forth, Racket, and Smalltalk far more valuable primarily because they are sufficiently accessible to be practical learning tools.

Kotlin and Dart also. Maybe the same reason? There isn't a preamble with the reasoning...they just jump right into the list.

Dart is designed to be uninteresting! But certainly Kotlin deserves a mention if Elixir makes it onto the list.

I was actually rather pleased that Haskell is omitted. It suggests that Haskell is now mainstream.

> Maybe most of the above are too mainstream for the list.

I'd agree with Haskell and Prolog, and probably people could guess based on the "Lisp" part of PicoLisp, but having experience with Rebol - no one I've mentioned it to has heard of it. I don't think it's mainstream at all.

Carp, Scheme, Elm

And K, Icon, and others.

Missing: Icon. I think Icon is a fascinating language in spite of being dynamically-typed. I've not used it in many years though.

What makes Icon interesting is that its functions ("procedures" in Icon terminology) are essentially generators in that they can "fail" (prune, produce no [further] results), or "suspend" results as many times as desired. "Failure" drives backtracking. So it's Prolog-like, but with Algol-family syntax.

Not surprising then that I find jq interesting too: it has pervasive generators and backtracking, just like Icon, though with a fundamentally different syntax, and very limited type system.

The first time I tried using Icon (over 20 years ago), I couldn't get my head around generators and back-tracking. Then I tried it again a year or two later and it suddenly clicked. But then I missed the availability of libraries in C, and the module structure of Modula 3.

So I rolled my own, (https://wrapl.github.io), combining Icon's goal directed evaluation with modules, classes, and lots of C library bindings. Unfortunately I wrote a lot of it in 32 bit x86 assembly, so it's due a proper rewrite but I still use it for prototyping and text / data processing today.

Do you like writing jq? I really tried to like it, appreciated the ideas, but found even simple programs extremely hard to write in it. (Obviously, this is possibly just an artifact of me being thrown into a functional deep-end with an extremely terse syntax).

Think of jq more like bash instead of a generic functional language. Blocks work on data and you pipe data along blocks. You can name blocks. That 99% of what you need to get to do jq.

Here's a small example of a smaller ETL script a wrote a while ago for stats collection over scm repos: https://gist.github.com/turbo/36e87947a56cfaacec9d0356b3e521...

As you can see it loads data from vars, fed by other jq scripts. Don't try to put everything in one script. Each script should basically just reduce and normalize.

It took some getting used to...

I "like" it the same way that I "like" writing XSLs: I thank my lucky stars that jq and XSLT/XPath exist, but if I didn't have to deal with JSON/XML I wouldn't use jq/XSLT. That reasoning seems circular, but at least jq is significantly more general than XSLT. Though to be fair I like jq a lot better than I like XSLT.

All functional languages tend to take some getting used to, at least for me. Now that I have a mental model of jq, I do actually enjoy using it.

The terse syntax is a double-edged sword.

The list seems rather arbitrary. To add to the list, I would consider also: CLIPS, Coq, Dhall, Factor, Inform, Stan.

>The list seems rather arbitrary

As opposed to what list? An exhaustive one? The quality he asks of the languages in the list is "interesting", which is by definition rather arbitrary itself.

I think it would be more useful if there was some criteria behind the list. Maybe there are, but I do not see what. It doesn't have to be exhaustive, there might be criteria like "not well known" or "representative of a certain idea".

This is a good (albeit exhaustive) list too: https://en.wikipedia.org/wiki/List_of_programming_languages_...

A more interesting list might be an <ol> with the first few languages to learn to cover the most good concepts.

But such a list would be a lot more decisive.

This is essentially the premise of the book Seven Languages in Seven Weeks.

And if it was an objective measure, there would never be a least interesting language, because if there were, then it would be interesting for that reason.

Elixir is Ruby like wrapper to a prolog based syntax to do actor based programming. It's more of a mess trying to move Erlang's syntax forward than interesting, but ok.

Ponylang is listed as "--" instead of "concurrency as a primitive type".

I'm not sure I can trust anything on the list, so it doesn't motivate me to investigate further. YMMV

I don't really care if it's a "list I trust".

I do care for a set of links to languages I've not seen yet, where I can click and check their websites -- and this provides it.

Good call on Inform. It's certainly both novel and useful.

I'm reading a lot about WebAssembly (which, I know, it's not a programming language per se), and more recently Dark (https://darklang.com).

My open question is whether in the coming 2-3 years there will be a significant paradigm shift in programming languages, or not.

My bet is that a combination of new, purpose-specific languages, together with "real" AI, will have a chance to have a big impact.

Where can u read about dark? The site has no docs on it.

Paul Biggar blogs about it on their Medium blog.

Link for the lazy: https://medium.com/darklang

Exactly - that's where I've read about it.

what's the paradign shift you are thinking might happen?

not OP. Not this specifically but this generally these types of changes. https://dotnet.microsoft.com/apps/aspnet/web-apps/client where we can run abitrary desktop languages in the browser is going to be huge.

There's no way to do this kind of list without infecting it with author bias. I'm a Rubyist, I like pure-OO, so what's interesting to me is language interop, so that I can get all the benefits of pure OO along with speed, and tooling so that you can get through the mass of context that is understanding the standard library and available libs so you don't have to build literally everything from scratch or spend 90% of your time in Google.

So I went looking for Pharo, which brings fascinating introspective tooling to Smalltalk, only to find that the author is biased towards 'any' high level features interoperating with C-like languages. And my list of interesting languages would look the same way, nobody would be able to see why I didn't put 'their' language on there.

Which is why I got excited for the awesome list thing. One person can't curate everything. You need a community of people invested in differentiating software offerings to the point where anybody can look at it and see what makes it interesting.

> There's no way to do this kind of list without infecting it with author bias

Well, “interesting” is subjective so it always is going to incorporate someone's opinion, but it doesn't have to be the author’s bias, e.g., if it was based, say, on surveying a wide and representative pool of developers.

I think about the concept of rationality a lot, and you touch upon a frequent topic of rumination. Does interestingness always have to be subjective? I don't think so, I think we can reduce it down to the contextual, and identify an ideal middle ground between the two. In that, we can make objective judgments that, given some context, a particular item sticks out and is therefore interesting. And that any interested curator could look at any new entrant and discover almost immediately what makes it interesting.

I think many machine language workloads boil down to searching for signal amongst noise. A human can then go look at the anomalies.

I wouldn't want a survey of a bunch of coders barely interested in curation. I want the guys who have been dealing with these things their entire careers and really care about the differences.

Not quite fully-automated discovery, but with a minimum of human fuss and a maximum of deliverable rational information.

I was hoping these would be more unusual.

My favorite thing is an impractically novel - maybe even intentionally useless - programming language. A way to describe a space of things that's truly alien; not even necessarily identifiable as a "programming language" aside from being interpretable by machines.

> Imba is a programming language for the web that compiles to performant and readable JavaScript. It has language level support for defining, extending, subclassing, instantiating and rendering dom nodes.

I found it odd to see this language up on the list, and not Elm.

I think “interesting” is “novel” in this context. Given that pretext, I think Imba is a better fit for this list than Elm.

UrWeb deserves a mention as well: https://github.com/urweb/urweb

While I've vaguely known it was around for a while, I recently had the pleasure of using `jq`. It has a genuinely different and extremely useful set of semantics. It allows you to easily define transformations over json object streams, and it's completely brilliant in how it goes about doing it.

Futhark definitely caught my attention from that list. I had never come across it before.

Are there any other languages which compile to OpenCL/CUDA? There are so many libraries built on them, but I haven't seen so many languages compiling to them.

COMAL was interesting ... "one of the few structured programming languages that was available for and comfortably usable on 8-bit home computers." Might still be used in UK education.

Too many details: https://web.archive.org/web/20180405152943/https://computera...

Kit looks interesting. Anyone have any experience or comments?

> Kit is a “Compiles-to-C” language. It is strong, and statically typed with many modern language features like type inference, algebraic data types, pattern matching, generics, implicits, while still having low level features like raw pointers, and manual memory management. Kit is written in Haskell. notes.

https://www.kitlang.org/

Anyone using Ballerina in production?

> Boomerang is a language for writing lenses — well-behaved bidirectional transformations

I love this unabashed reference to the original use of the term "lens". I love Haskell, but I'm embarrassed by its later, different use of the term "lens".

What is the difference you're referring to? As I understand it they are the same.

> bidirectional transformations

Isn't that called an isomorphism?

Bidirectional implies bijections, for isomorphism you'll need a morphism, a function that preserves/transposes some kind of structure or internal composition law (addition, multiplication,...)

Interestingly, from the point of view of category theory, an isomorphism in a category is just a morphism with a two-sided inverse. A bijection is then just an isomorphism in the category of sets.

Has anyone actually used these in production or a feasible side project?

Looking forward to implement sparse voxel octree code with iterative mesh refinement with Chapel. I forgot about it, because it was unusable for GPUs back when I first had contact. And now it seems good enough for non-GPU code and maybe even GPU code in comparison to C++.

I expect a few 10s of TB ram to be required for a specific dataset, which practically rules out any shared-memory approach. Clusters should be better above a few hundred GB anyway, maybe less depending on network bandwidth vs. RAM needs.

I have not used it personally, but Elixir is certainly in use in quite a few production environments.

Even if not used in production, Self is one of the influential ones on the list. Self did JIT before Java, did prototype object model before JS, and did visual morph objects that I'd guess influenced Squeak and others.

I use Rebol for almost all my side projects; it's the first language I learned back around 2000, and the direct ancestor of Red, which is on the list.

Currently doing one in Zig.... we'll see how it goes.

I was looking for Planner (which never got past a subset implementation called Micro-Planner, used by Terry Winograd to implement his natural language understanding program SHRDLU), and Conniver.

SNOBOL: Was the first language that opened my eyes that there was more to computing then numbers. Up to that point, college was all FORTRAN, Cobol, and a bit of CDC 6600 assembly.

Very cool list!

Maybe Ragel deserves a mention: http://www.colm.net/open-source/ragel/

This is fantastic!

Thank you very much. I wanted such a list for more than a year.

As people suggest below, it can be improved by adding more languages.

Thanks for including Euphoria in this! Nice to see our language still getting some love.

Of note: Hy.

As another lisp dialect Hy might not be interesting enough.

It’s rather nonstandard, since it has to follow Python closely.

Has no cons or let. OTOH: has defmacro.

I was curious and disappointed to find that there is no blurb about Nim. Not had a chance to give it a go yet?

I have a whole page on nim here - https://www.btbytes.com/nim.html

Edit:typo

Anyone tried Crystal yet?

This list is far from being complete. Brainfuck is missing ;-)

Reply on news.ycombinator.com