
Elixir v1.3 released - andruby
http://elixir-lang.org/blog/2016/06/21/elixir-v1-3-0-released/
======
eddd
I use phoenix and elixir, I agree with the statement that Elixir is awesome.
But don't drink too much cool-aid - Elixir might be dangerous as well.

It is essentially a big pile of macros, so sometimes number of keywords that
you have to keep in your head is staggering. Also, Elixir is a pretty big
language - I knew Erlang before diving into it - so the barrier and number of
concepts that you have to get familiar with is huge. Don't get me wrong - all
these concepts/design patterns are necessary (I am thinking about BEAM and OTP
here). Erlang (and therefore Elixir) is complete as development environment,
that's where the amount of knowledge is coming from.

Cool intro to erlang/BEAM: [http://www.slideshare.net/BrianTroutwine1/erlang-
lfe-elixir-...](http://www.slideshare.net/BrianTroutwine1/erlang-lfe-elixir-
and-joxa-oscon-2014)

~~~
yelnatz
I use elixir (and phoenix) as well, and this is my biggest gripe with the
language.

When reading (and reviewing) code, sometimes you can't logically follow what's
going on since most of the code is hidden behind macros.

It's ok if I'm on my IDE that helps expand macros to quickly check the flow,
but when it's on a webpage or in a gist somewhere, you're on your own.

~~~
Donwangugi
Which IDE do you use? I have been messing around with alchemist on emacs but
the learning curve is pretty steep (i'm not an emacs guru).

~~~
eddd
I can recommend: Atom with [https://github.com/msaraiva/atom-
elixir](https://github.com/msaraiva/atom-elixir)

------
bcardarella
If you're looking for a reason to migrate from a stack like Ruby/Rails to
Elixir/Phoenix you should check out my RailsConf talk on that exact subject:
[https://www.youtube.com/watch?v=OxhTQdcieQE](https://www.youtube.com/watch?v=OxhTQdcieQE)

~~~
ffn
Thanks for all the work you and the good folks at Dockyard put into Elixir
Phoenix and Ember.js, my entire stack nowadays is run with Ember in the front
and Phoenix in the back, so I very much appreciate all the great addons,
packages, talks, etc., you guys have given.

~~~
bcardarella
We love to reinvest in the open source community. :)

------
constantlm
Great! We're busy rewriting a part of our Rails app that we are having
difficulty scaling in Elixir. So far what I've seen is phenomenal. Coming from
Ruby/OO, it's a bit weird sometimes, but the code is very readable and it's
insanely fast. Really the first language since Ruby that I'm quite happily
riding the hypetrain for.

~~~
appleflaxen
We're busy rewriting (a part of our Rails app that we are having difficulty
scaling) in Elixir

or

We're busy rewriting a part of our Rails app (that we are having difficulty
scaling in Elixir)

I assume the former, based on context, but like they say... you can't put too
much water in a nuclear reactor.

------
insulanian
Anyone here switched from a statically typed functional programming language
(Haskel, OCaml, F#, Scala...) to Elixir? How would you describe the
experience? What do you miss? What do you like/love? Overall, would you
recommend taking that step?

~~~
shrugger
I switched from Ruby to Scala, and I have had an absolute blast. Elixir is
sort of chained to BEAM, which doesn't appear to have as bright a future as
the JVM or LLVM does, so Scala seemed like a safer bet.

Reading about Elixir is cool sometimes, but then I look at Dotty, and I feel
confident that I made the correct choice.

I've also been keeping an eye on Crystal (statically typed Ruby-esque
language, LLVM), but they aren't making great PLT choices so far. Maybe
they'll get it together later. Scala-Native will blow it out of the water most
likely anyways.

Sort of the opposite of losing statically typed programming, but I've really
enjoyed the journey and it's improved my work a lot more than I thought it
would. I know Ruby pretty well and I used to feel really dumb all the time
when things would break, and it took some time for me to realize that it was a
language problem. Looking back and reading some of the Ruby that I ported, it
was impossible to reason about, and very difficult to make guarantees for.
Nothing was solid at all, and runtime errors could hypotehtically stop the
show at any time. With Scala there's a much sharper baseline of what will
definitely work or not work.

Types make a LOT of things so much easier, in exchange for making a few things
SLIGHTLY more tedious. After doing it, I'd make that trade ten more times if I
had to.

~~~
josevalim
> Elixir is sort of chained to BEAM, which doesn't appear to have as bright a
> future as the JVM or LLVM does, so Scala seemed like a safer bet.

Where does this impression come from? The BEAM VM is maintained by Ericsson,
we get new "major" releases every year. In the last years we got the maps data
type, the new scalable timer API, better tracing facilities, dirty schedulers,
and so on. Lately, at ElixirConf Berlin, we heard about the current efforts on
scaling the Erlang Distribution to thousands of nodes out of the box (it is
already possibly today, just not by default).

They are also plenty of research projects, mostly in Europe, about improving
the VM, development experience and scalability in different ways, such as
[http://release-project.eu/](http://release-project.eu/),
[http://www.prowessproject.eu/](http://www.prowessproject.eu/) and
[http://paraphrase-ict.eu/](http://paraphrase-ict.eu/). That's not including
the usual suspects like Chalmers and Uppsala in Sweden, which have been
exploring different aspects, specially in the testing area with property-based
testing, concolic testing, systematic concurrent testing, etc.

Companies like Adapteva (behind Parallella), Basho, Erlang Solutions,
Plataformatec, and many more are investing in the ecosystem too. If there is
one thing I am not worried about is the VM and the runtime bright future.

In my opinion, the simple fact we have a runtime with preemptive light-weight
processes from the ground-up (instead of tackled on top as a
library/framework) with per process garbage collection and inter-node
communication taken care of is enough to hold the VM for the next handful of
years, even if all development ceased today.

~~~
acangiano
I would argue that Elixir's success will further guarantee BEAM's future. (Not
that it would die otherwise, but it doesn't hurt.)

------
andybak
I've never really looked into Elixir. I'm a Python guy and readability is the
first thing that makes me love or hate a new language. Considering I've always
found Erlang fairly obtuse visually I am surprised by how easy on the eye
Elixir is.

I found this quote very telling:

> "Elixir is simply the first language since Ruby to really care about code
> beauty and UX of the language, libraries and ecosystem."

(found here: [http://ruby2elixir.github.io/posts/2015/12-29-what-makes-
eli...](http://ruby2elixir.github.io/posts/2015/12-29-what-makes-elixir-so-
attractive-for-some-developers.html#qertoip) )

(Of course they meant 'Python' instead of 'Ruby' but hey ;-) )

~~~
ams6110
I started out learning Erlang before Elixr had really crossed my radar. I have
to say I prefer the Erlang syntax to the ruby-inspired Elixir. Maybe just a
matter of what you know, I could see a RoR developer finding Elixir more
appealing (I've never really used Ruby or Rails at all).

~~~
partisan
Agreed. The syntax and benefits would certainly appeal if I were a Ruby
developer, but coming from a different perspective, I don't get the reason for
all the love.

~~~
xutopia
What about the pipe operator in Elixir? Isn't it tedious and less readable to
apply the same logic in Erlang?

------
antipax
Super excited for this release.

I have to say that learning and using Elixir has been more pleasant than any
other language I have ever worked with. Code is easy to follow due to the
functional nature of the language, and the community is one of the best out
there.

The applications I've written and deployed have been more stable and fault-
tolerant than anything else I've ever done, and I've yet to have any
performance issues with the language in production.

~~~
devbug
How hard have you pushed Elixir in production?

Snide aside, it's not this mystical technical panacea. As for community... it
has had a large upswell of Rails developers... for better and for worse.

That said, I've had a wonderful experience with all the places I've used
Elixir in production or soon to be in production.

~~~
antipax
Quite hard, in fact.

My own personal experience doesn't matter much, though, because ultimately
Elixir _is_ Erlang and obviously Erlang has been pushed extremely hard in
production (Klarna, Heroku, Riot Games, etc.).

------
matthewrudy
Elixir 1.3 and Ecto 2.0 are now both released. That means Phoenix 1.2 will be
released ASAP.

Definitely give the Programming Phoenix book a read if you haven't already.
The Elixir/Phoenix stack should be ready for most production environments now.

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

~~~
sotojuan
Is there a good guide to Ecto? Aside from OTP, it's the part I have the most
trouble with in Phoenix/Elixir.

~~~
matthewrudy
Somehow I've never heard of "sectors" and google isn't any help.

Is there a different name for this concept used in Elixir/Erlang world?

~~~
sotojuan
Autocorrected from "Ecto" :-)

------
TY
Awesome! Elixir is quickly becoming my new go to language for the web apps and
more.

Come for concurrency, stay for metaprogramming. :-)

~~~
nailer
> Come for concurrency, stay for metaprogramming. :-)

hehe. I've only done a bit of Elixir, but coming from a node and Python
background that's pretty accurate:

\- It should be the VMs job to take care of concurrency, not the programmers

\- Although functions having different signatures is common in the front end
JS world (mainly due to jQuery) metaprogramming is a nicer way to do it.

Also 5-10ms response times for a basic Phoenix web app is pretty rad. If I
wasn't building a startup and thus had the time, I'd love to do more Elixir.

------
sergiotapia
`mix test --stale` sound like a tremendous gain in productivity, can't wait to
use it.

Is there a way to have `mix test` just call --stale steamlessly for me in my
terminal?

The other updates to testing in general signal how important testing it to the
Elixir core team, and should be a flag letting you know how robust this
language and it's tooling is. Take a look for sure, it's a great language.

~~~
andy_ppp
You can set aliases in mix.exs...

Search for aliases on this page:

[http://elixir-lang.org/docs/stable/mix/Mix.html](http://elixir-
lang.org/docs/stable/mix/Mix.html)

~~~
sergiotapia
Oh that's nice, will do.

------
flocial
l used to be/still am a ruby on rails developer. I wrote a very naive web
crawler in elixir within a week while learning elixir and I'm blown away by
the performance. It basically maxes out my 2011 macbook air's cpu while
staying under 200MB of RAM (and maybe another 500 for multiple postgres
connections). It basically runs in the background on a computer that can
barely handle Firefox with multiple tabs open. The only real bottleneck of my
crawler is bandwidth (my internet speed). The performance you get out of the
box is insane. And my app really sucks (individual database inserts, saving
the entire html to the database, etc).

The transition to a functional language is not exactly a cakewalk and I
honestly still miss ruby's ability to be able to hack through arrays (no way
to easily get the nth element of an array, it's all head|tail recursion) and
hashes (nothing like hash[:key]) to make something "work" but the pipe
operators and pattern matching are addictive. The eco system is not
"opinionated" at all aside from the constraints of erlang. Documentation is
crystal clear. Most of the phoenix stack can be used as stand alone
libraries/dependencies. There's a lot less magic and most of the "magic" comes
from macros which are much more transparent.

I'm honestly excited for web programming again after being burned out on
legacy rails app development and deployment. Mix is like gems/bundler/rails
{console, server, etc.} in one neat package done right and minus the
headaches. Jose Valim and Chris Mc Chord are brilliant but are very
approachable and all around nice people to interact with. In my short time
with Elixir/Phoenix I'd say the "hype" actually understates the true potential
of BEAM for web development and tiny startups. Also there's also LFE (lisp
flavoured erlang created by one of the creators of erlang) you can add to the
mix (similar to what you have with Scala/Clojure + Java only with concurrency
and multicore out of the box with a tiny RAM footprint).

Learning Elixir was one of the best investments of time I've made in learning
a new language and made programming a "hobby" again for me. Being able to
write a naive implementation/prototype of an app and not dreading a "real"
deployment (pulling out a bag of deployment tricks or stringing together a
slew if external libraries/dependencies) is the most liberating experience
I've had in a long time.

~~~
dpeck
Not that you should do it too much since traversing arrays (lists) is
expensive, but [http://elixir-
lang.org/docs/stable/elixir/Enum.html#at/3](http://elixir-
lang.org/docs/stable/elixir/Enum.html#at/3) gives you the ability to grab
arbitrarily.

------
tomekowal
I am working full time with Elixir and Phoenix for more than one year now and
worked with Erlang before that. It is great to see how well thought out all
the abstractions are (both in the language and in the framework). I saw couple
of companies cautiously introducing Phoenix in their stack and then going all
in. One of such stories will be presented at Erlang User Conference:
[http://www.erlang-factory.com/euc2016/ben-marx](http://www.erlang-
factory.com/euc2016/ben-marx)

Comparing to Ruby: Phoenix promises to be as productive as Rails, but more
performant and it keeps the promise if all the libraries you need are already
ported to Elixir. Even if not, people consider writing them from scratch.

Comparing to Erlang: Elixir fixes a lot of problems like encoding or
inconsistencies in standard library. It introduces many new concepts borrowed
from Ruby so it might be a little overwhelming for Erlang developers (Erlang
is really small and simple language - the hard part is OTP).

Learning Elixir is like learning to touch type. Initially it slows you down,
because you have your habits. You need to learn new abstractions, because old
solutions just don't work. After short period you are as productive as before.
After a month you can deliver hight quality code quicker which is the ultimate
goal of every programmer :) And it magically scales on more machines or at
least utilizes all of the cores.

------
rafadc
The diffing in the tests is absolutely beautiful!

Congrats.

------
ch4s3
Looks great. Any clue when this will be up on Homebrew?

~~~
somlor
Another nice option is kiex, Elixir version manager:
[https://github.com/taylor/kiex](https://github.com/taylor/kiex)

~~~
s0l1dsnak3123
I'm using asdf - it has the added advantage of being able to manage ruby,
erlang, node, and more :) [https://github.com/asdf-
vm/asdf](https://github.com/asdf-vm/asdf)

~~~
ch4s3
Oh, cool. I've never heard of that, but it looks nice. Thanks!

------
oblio
How are the resource usage and performance for Elixir/Phoenix compared to
Ruby/Rails and even something like Java/Spring Boot?

~~~
bcardarella
Significant. You can see some data in a RailsConf talk I recently gave:
[https://www.youtube.com/watch?v=OxhTQdcieQE](https://www.youtube.com/watch?v=OxhTQdcieQE)

------
ngrilly
Is Elixir/Erlang/BEAM a good fit to write small command line programs (the
kind of programs you could write in Python or Go for example)?

I have three specific questions about this:

\- Can you make your program executable directly from the command line, by
using a shebang and building an executable binary?

\- What about the startup time?

\- Do you need a lot of "boilerplate", or can you put everything in a single
file?

~~~
RobertKerans
Yes, _kinda_ \- you can compile to an escript, and mix makes that super easy.
_But_ it needs an Erlang environment - you can't easily compile to an
executable that will work anywhere, so it can be limiting. If you're happy
with that limitation, yes and yes to the latter two questions. Otherwise, I'd
stick with what you're using.

------
davidw
Without digging into it, the Calendar stuff looks like a strict improvement
over Erlang's tuply handling of dates, times and timestamps, which are all
tuples with three numbers. This can be confusing/problematic, and something
that would benefit from typing to avoid mixing up Dates with Timestamps, say.

Can anyone who knows both confirm?

~~~
antipax
Yes, it absolutely is an improvement over erlang-style tuples IMO, and it also
vastly improves the interoperability story between the stdlib,
date/time/calendar libs, and database libs.

------
revo13
Thanks Elixir team!!

------
rcarmo
This is good news, since a few tooling improvements have made it back to the
Erlang ecosystem in general (and to lfe.io in particular, which I prefer over
Elixir).

------
biot
Any best practice guides for running Elixir in production? How do you handle
deployments, hotfixes, multi-node scaling, etc. in an automated way?

~~~
bratsche
This doesn't answer all of your questions, but it was the fastest way I found
to get an Elixir app into production:

[https://github.com/boldpoker/edeliver](https://github.com/boldpoker/edeliver)

It handles all the basic things I needed to get an app up and running, and
supports hot-code upgrades. It supports multi-host deployments, but I think if
you want auto-scaling you'll need to do some more work.

One thing to be aware of is that if you're deploying any NIFs or any native-
compiled code, not BEAM, then you can't deploy directly from Mac to Linux
servers, you'll need to use VMware or VirtualBox or something to actually do
the builds. This includes any packages you use which are using natively-
implemented code, which I'm pretty sure includes packages that do password
hashing and such.

~~~
biot
Thank you. I hadn't run across that... it looks amazing.

------
CalmStorm
With hot code reloading, high reliability and fault-tolerant of BEAM, I feel
that writing web apps is like writing carrier class applications.

------
brightball
Building my first project with it now and loving every minute of it.

------
josevalim
The proper announcement can also be found on our page: [http://elixir-
lang.org/blog/2016/06/21/elixir-v1-3-0-release...](http://elixir-
lang.org/blog/2016/06/21/elixir-v1-3-0-released/)

It is slightly better formatted and contains images from the graph commands
and ExUnit diff format.

~~~
sctb
Thanks! We updated the link from [https://github.com/elixir-
lang/elixir/blob/v1.3/CHANGELOG.md](https://github.com/elixir-
lang/elixir/blob/v1.3/CHANGELOG.md).

~~~
josevalim
Perfect! :D

