Hacker News Reader

Comment by felixgallo | Hacker News Reader

IMO the eighth ur-language is Erlang (with cousin Elixir), which brings the ultra-scaling actor model, an abstract operating system designed for high reliability and low latency, and a bunch of nice rare features like builtin binary structuring/destructuring and pattern matching. While it had its origins in prolog, it's now sufficiently far away from prolog's inner machinery that it only has syntactical similarity.

Learning erlang made me definitely at least 10% smarter as a programmer. Highly recommend, even if you never use it in anger.

View on HN

Erlang is a nice and unique language, but I feel at its core it falls into the object-oriented/message-passing paradigm, very much in the vein of Smalltalk. Consider these paragraphs from Smalltalk's Wikipedia entry [1]:

> A Smalltalk object can do exactly three things:

> 1. Hold state (references to other objects).

> 2. Receive a message from itself or another object.

> 3. In the course of processing a message, send messages to itself or another object.

Replace "Smalltalk object" here with "Erlang process" and the description holds.

> Unlike most other languages, Smalltalk objects can be modified while the system is running. Live coding and applying fixes ‘on-the-fly’ is a dominant programming methodology for Smalltalk and is one of the main reasons for its efficiency.

Erlang's famed robustness similarly owes much to its ability to update code in a running program.

[1] https://en.wikipedia.org/wiki/Smalltalk#Object-oriented_prog...

Joe Armstrong talked about that in the past, and I can sort of see it if I squint, but at the end of the day, there are a lot of things in Erlang that are not processes, like most of your basic data types, so I'd just say Erlang is good at borrowing, like a lot of practical real world languages are, and in doing so, came up with a niche where it's pretty good. It takes things from the FP world, its syntax from Prolog, and definitely has message passing as an integral part of how you architect a system with it.

Fair point! It definitely is a mishmash of good ideas. I think the message passing / OO aspect stands out to me as most distinct from other languages, even if it's not as pervasive in the language as in Smalltalk.

It's funny to me. OTP Processes have a ton of similarities to Agents, but from what I recall it sounds like those two things were developed almost entirely independently and it wasn't until way after the fact when people outside of Ericsson started using Erlang that people started noticing and commenting on that.

I agree. Many of the core language concepts from Erlang you can get from Self and Prolog, but experiencing the OTP is something different that I think you only get from the Erlang family.

Likewise, experiencing JVM is something different from ALGOL ...

And not quite sure if SQL could be grouped together with Prolog due to its declarative nature. But if so, DBMS is, like OTP, quite far from Prolog, just in a slightly different direction :)

I guess what I'm trying to say is that the list of ur-languages seems quite fine to me.

That was my first thought, reading this. Although it’s almost like a combination of lisp, self/smalltalk and prolog, with OTP being the innovation.

That got briefly mentioned in the Object-Oriented section. It's worth noticing that the article specifically excluded Java and C++ from that section, putting them in the Algol heading instead. Smalltalk and Erlang share enough ideologically that it seems reasonable to me.

I disagree that Erlang is an ur-language (it's too close to the Self and Prolog ur-languages to be its own, IMO), but I do agree that OTP/ERTS could be a sort of ur-framework or ur-runtime, for exactly the reasons you describe: even explicit attempts to implement "Erlang-style concurrency in $LANGUAGE" routinely only cover some superficial "yeah we've got actors that pass messages and maybe supervise one another" without covering preemptive multitasking, hot-reloading of functions, distribution across nodes, and the myriad other features that give Erlang its reputation for extreme fault-tolerance.

Reply on news.ycombinator.com