
Erlang is pragmatic - hassy
http://12monkeys.co.uk/2009/05/16/erlang-is-pragmatic.html
======
RiderOfGiraffes
The paper linked to is of much greater value than the blog entry.

[http://www.cs.chalmers.se/Cs/Grundutb/Kurser/ppxt/HT2007/gen...](http://www.cs.chalmers.se/Cs/Grundutb/Kurser/ppxt/HT2007/general/languages/armstrong-
erlang_history.pdf)

~~~
jhancock
Here is Joe Armstrong's doctoral thesis.

<http://www.sics.se/~joe/thesis/armstrong_thesis_2003.pdf>

I find it highly readable.

------
Tichy
The same point could be made about Java ("we noticed that language feature x
lead to a lot of probelms in the field, so we decided to leave it out of
Java").

~~~
stcredzero
All you need to consider:

    
    
        - Is it useful?
        - Is it fun?
    

Just OR these two to see if the language has justified its existence.

------
charlesju
Here is something that I have been toying with, please downvote me if you guys
think this is out of place:

Why do you need so much fault tolerance and concurrency? It seems to me that
the regular server would only need to thread a little bit, process incoming
requests, and shoot out responses. (this is assuming you're not building MySQL
or a heavy duty web server)

~~~
oomkiller
Lots of people starting to use Erlang needs fault tolerance for high
availability, and high concurrency because they need to scale massively.

YAWS, one of the more-popular webservers written in Erlang (that has docs,
unlike Mochiweb), blows Apache out of the water when it comes to serving many
users (<http://www.sics.se/~joe/apachevsyaws.html>). Apache can serve about
4,000 parallel sessions on the same hardware YAWS can serve at least 80,000
parallel sessions. This is due to the high level of concurrency that Erlang
enables and encourages.

Another example is ejabberd, one of the most popular Jabber/XMPP servers. It
takes advantage of the high concurrency also, which allows is to process many
more connections than Openfire or the C-based jabberd and jabberd2.

------
pookleblinky
Stopped reading it after the sentence "Erlang is not a functional programming
language."

edit: [http://james-iry.blogspot.com/2009/05/erlang-is-not-
function...](http://james-iry.blogspot.com/2009/05/erlang-is-not-
functional.html) and others seem to agree that "functional" is not the antonym
of "practical/pragmatic/useful."

~~~
silentbicycle
I think you misread his intent -- The point he's making is that Erlang grew
organically into its current form by way of continual sculpting during use by
its creators, rather than being refined to approach a theoretical ideal. You
seem to think this he means this as a slam on functional programming, but I
don't think that's the case.

Going one further from the linked blog post, is OCaml functional? By Fischer's
definition, yes, but I've written very non-functional (ha) code in OCaml. It's
a multi-paradigm language, which happens to have very good support for
functional programming, but it isn't limited to it. (I've also written very
functional code in idiomatic Lua. Is Lua functional, then?) While functional
programming techniques don't go against the flow of Erlang, saying it's
functional is probably a bit of a stretch - its design doesn't prioritize this
the way Haskell's does.

(HN favors substantial comments over one-line reactions, btw. "I didn't bother
reading this" doesn't add much to the discussion.)

~~~
plinkplonk
"The point he's making is that Erlang grew organically into its current form
by way of continual sculpting during use by its creators rather than being
refined to approach a theoretical ideal"

This might be an interesting language design methodology. Try to code up
something _hard_ (to introduce constraints) and assume you have to build a new
langauge to do it. Iow ignore existing languages/libraries etc.

~~~
silentbicycle
A lot of interesting mini-languages (e.g. make, regular expressions, and yacc)
have formed that way.

