
Elixir 1.0.5 released - gandarojin
https://github.com/elixir-lang/elixir/blob/3eb938a0ba7db5c6cc13d390e6242f66fdc9ef00/CHANGELOG.md#v105-2015-06-29
======
sivers
I sponsored the OpenBSD port of Elixir 1.0.5 & Erlang 18:

[http://cvsweb.openbsd.org/cgi-
bin/cvsweb/ports/lang/elixir/](http://cvsweb.openbsd.org/cgi-
bin/cvsweb/ports/lang/elixir/)

So it'll be included in OpenBSD 5.8.

~~~
reitzensteinm
That's awesome! Could I ask why? Are you using it to build anything public?

~~~
sivers
Hopefully some day! ☺

All my programming is public, so if I ever start making something with it,
it'll be at [https://github.com/sivers](https://github.com/sivers)

But I'm a fan of OpenBSD, and like to make sure it stays current. I've
contributed a few thousand $ over the years to help.

And I'm a fan of Dave Thomas from Pragmatic Programmers, so when I heard him
raving about Elixir, I had to give it a try. I like it so far.

Good overview video:

[https://www.youtube.com/watch?v=hht9s6nAAx8](https://www.youtube.com/watch?v=hht9s6nAAx8)

Good books:

"Introducing Elixir - Getting Started in Functional Programming"

[http://shop.oreilly.com/product/0636920030584.do](http://shop.oreilly.com/product/0636920030584.do)

"Elixir in Action"

[http://www.manning.com/juric/](http://www.manning.com/juric/)

"Programming Elixir"

[https://pragprog.com/book/elixir/programming-
elixir](https://pragprog.com/book/elixir/programming-elixir)

------
jfaucett
Haven't looked at elixir yet, but being an erlang fan and quickly hopping
through the source it looks like elixir is doing for erlang essentially what
coffeescript does to javascript. Something many non-erlangers have long
lamented is the syntax so this looks quite interesting, also adding the
running compiler is a nice idea for the macro support :)

~~~
josevalim
Hi, Elixir creator here, thanks for commenting! You may want to watch my talk
at Erlang Factory SF 2015:
[https://www.youtube.com/watch?v=Lqo9-pQuRKE](https://www.youtube.com/watch?v=Lqo9-pQuRKE)

Elixir is not really about the syntax, we have great tooling, our own standard
library (with proper Unicode support, collections, unified API for
dictionaries, etc) and our own approach to some constructs in OTP.

Feel free to ping here if you have any questions. I will make sure to check
this thread again later.

~~~
ffn
Love the language, I've been using it (phoenix) to build a more real-time
version of my current rails app. But I have a concern with Elixir core's Enum.
In particular, the Enumerable protocol has us implementing Enum.reduce for our
own data-types, but Enum.map is written as

`reduce(collection, [], R.map(fun)) |> :lists.reverse`

is there any chance Elixir's enum core can take a page from Clojure's
transducer idea and, instead of implementing map with reduce and [], implement
it with transduce and some function that steps?

I've often had the need to map and filter over strings to achieve rails-like
features such as #to_url, #classify, #underscore, and #humanize... but being
forced to either rewrite Enum functions for strings or constantly peppering in
String.split("") and Enum.join("") feels really bad.

~~~
josevalim
It would be possible to have something like `Enum.map |> Enum.into`. You could
also do `Stream.map |> Enum.into` if you don't want to traverse it multiple
times (similar to Clojure's `into`). In fact:

    
    
        iex> Stream.unfold("hello", &String.next_codepoint/1) |> Enum.to_list
        ["h", "e", "l", "l", "o"]
    

The reasons we don't have first class support for this though are:

1\. There are multiple ways you could traverse a string. By bytes, by
codepoints or by graphemes. I don't think we should pick any of those as
default. Ruby did that and to this day it is source of confusion (aggravated
by the behavior change from 1.8 to 1.9)

2\. Modifying strings like this would be horribly inefficient. Using
split/join wouldn't be recommended also as you are generating a bunch of
intermediate garbage to go from string -> string. The recommended way is to
rely on pattern matching and Elixir's bit syntax as the compiler will be able
to optimize most cases well.

------
Xophmeister
I've been reading about Elixir here-and-there for a while and decided to jump
into it last week. I really like it. I'm a big fan of FP and, having
increasingly found myself falling out with Python, can definitely see this
becoming my dynamically typed language of choice.

~~~
fokinsean
Would you recommend Elixir for a first FP language? I am familiar with FP from
using Python and JavaScript, but I have never used a completely functional
language yet. Can I dive into Elixir or should I learn something more
"traditional" first such as Haskell, Lisp, etc?

~~~
Xophmeister
My current feeling [bearing in mind that it's been less than a week!] is that
Elixir is to Haskell as Python is to C++. If you want to learn a dynamically
typed FP language, then I think Elixir is a fine choice; especially from a
JS/Python background, plus all the goodies that come with the Erlang VM. I've
read it's also good for metaprogramming, so it ticks the same boxes as Lisp,
without having to get used to S-expressions!... It's certainly something you
can dive into :)

Then, if you find you're really in to the FP Kool-Aid, I would definitely give
Haskell (or OCaml) a try as well. It's a completely different ball game, but
even as just a beginner -- I kinda-sorta-understand monads -- I would say that
it's already improved my general programming skills.

~~~
fokinsean
Thanks for the suggestion, I will definitely be giving Elixir a try!

------
arms
I'd love to read about people's real life uses of Elixir, whether it be for
their jobs or side projects.

~~~
vezzy-fnord
I can't see how they would be much different from the use cases of Erlang/OTP,
of which there are plenty of stories.

~~~
arms
I'm interested in more than just the use cases (although still curious to hear
_why_ someone chose Elixir, whether it be for the language, BEAM, or
whatever.) I'm looking for stories of why it was chosen over another language
and what the end results were.

~~~
hderms
Well neither will win any speed races, but if your problem requires soft-
realtime functionality, concurrent execution, or incredible fault tolerance
you'd do much worse than to choose Elixir/Erlang. And a simpler learning curve
than many FP languages (in my experience, at least) sweetens the deal.

