
Erlang 16B Released - davidw
http://www.erlang.org/news/43
======
rdtsc
Also can get pre-built CentOS, Ubuntu and Debian packages here:

[https://www.erlang-solutions.com/downloads/download-
erlang-o...](https://www.erlang-solutions.com/downloads/download-erlang-otp)

(Courtesy of Erlang Solutions).

Readme of all the changes:

<http://erlang.org/download/otp_src_R16B.readme>

------
throwawayG9
The last few days I have been digging into the functional world, because I
can't ignore it anymore. Lots of developers I respect say it will make you a
better programmer, and you can even use it for building real things (like
websites), not just calculate a fibonacci in fewer lines. I'm so lost, I
thought there was only 2 or 3 languages, but there are a lot. I figured I
should just read some code and pick based on my feelings, but most of it is
unreadable for me right now. Some use the java VM, others are native. Some
people say you should use their language, some others say you should use them
all.

Does anyone have some advice?

~~~
fusiongyro
If the goal is to learn to think functionally, you should concentrate your
attention on one or a couple of the big old ones and avoid the Java hybrids
until you're more comfortable.

Choosing which one is a matter of personal preference. Erlang is the best
choice if you're interested in concurrency and distributed programming. It's
also in a sweet spot where variables are bound once, which forces you to
change the way you think. I consider this more important than purity for
learning.

Haskell is probably the biggest paradigm shift. I use it a lot and love it. It
really does change the way you think, but it is also the steepest learning
curve.

Of all the Lisps, Scheme is the simplest and tends to be used functionally
more often than Common Lisp. There is an incredible wealth of resources for
people learning Scheme, but especially The Little Schemer and Structure and
Interpretation of Computer Programs (SICP). I have never made much progress in
my copy of SICP, but I got a lot out of the Little Schemer. I said to avoid
JVM languages but Clojure is the most modern Lisp, and incorporates a lot of
modern functional programming idioms, so it can sometimes have a Haskellish
flavor, and it doesn't make circumventing FP all that easy. It's probably the
best Lisp of today.

Standard ML and OCaml are both good if it looks to you like Haskell goes too
far but in the right direction. OCaml is considered more pragmatic; it's also
more widely available and benefits from being a single-implementation
language. Standard ML is arguably a more beautiful language, but it suffers
from low library availability. Both will encourage functional-style
programming, but both provide a fair number of escape hatches. For example,
they're not pure and they both have "refs" that let you circumvent variables-
as-bindings. But they encourage the style.

I tried many times with Lisp and eventually concluded it just wasn't for me,
and Haskell is a better fit. I personally recommend looking at Erlang, Clojure
and Haskell, and just throwing yourself into whichever one of them looks
"cool" to you. If the language feels unpleasant to you, there's no point in
trying to force yourself to go further, but if it seems fun to you, you'll
make progress without as much effort.

~~~
bitcartel
Have you tried (and if so, do you like) F# ? <http://fsharp.org/>

~~~
fusiongyro
I have a positive opinion of it but I haven't used it myself. I would imagine
it deserves the same caveat as JVM hybrids do: having an easy escape hatch may
ease the learning curve, but it can also extend the time it takes to become
proficient.

------
itsybaev
Joe Armstrong: I came up with Erlang, because it didn't exist
<http://news.ycombinator.com/item?id=5247531>

------
cribbageisfun
I love Erlang. As someone said it is a complete platform. It is like a
programming language, middleware, system monitoring software, database all
rolled into one. Plus it was originally designed to create telephone switches.
Bulletproof reliability was the primary concern.

------
nirvana
FWIW, In Erlang Land, the "A" release (eg: 16A) is the "beta" and the "B"
release is the "finished" release.

So 16B is the complete, ready for production version of 16.

Next release will be 17A, or 16B2 if there are bug patches required.

Also, it may seem weird that a "programming language" is having an update each
year. (how many times a decade is C++ updated?) But this is because erlang is
really a complete platform. The language is just part of it, but OTP, the
platform is a hidden gem that gives erlangers super powers.

This also means, each year, your code gets better as the platform itself gets
better.

