Good morning .. ahh I'm really excited to
do this talk because it's actually the
first time I can give a talk about Elixir
and assume that the audience knows what
Elixir is, right?
(laughter)
So that's really great, that's really..ah
changing face because usually I'm going
to other conferences and I'm always giving
the introductory talk, right? What Elixir
is about, what are the language goals.
So this talk is not about that okay?
This talk is about Elixir past and future.
I think it's kind of expected to talk
about from where the language came,
because now we are close to reach 1.0.
And I think there are important lessons,
things that happened throughout this
process that we could share, that could
help the community grow.. ah.. together.
So if we want to talk about Elixir past,
one think we could do is that we could go
to the Elixir timeline. So this, I got it
from GitHub. So, the vertical, we got the
number of commits, and I think it's per
week, and we have the whole year of 2011
in there. And the first commit was right
at the beginning of 2011, okay, it was
like 9 January or something like that. But
I actually want to rewind a little bit
more, okay, I want to go a little bit back
before 2011 but not too much.. it's not
about my birth or anything like that. It's
when...I'm going back to 2005 and I choose
this article, The Free Lunch is Over,
because it was about this time that I was
personally starting to get aware of the
changes that are happening. So The Free
Lunch is Over is a paper from Sutter and
basically what he's referring to .. ah ..
the free lunch, it's not about this
conference, you still have free lunch, so
don't worry. But basically, what he was
talking about is that ah throughout the
previous two decades or even more, you
wrote software and then you could just
wait like two years? and your software
will run twice faster, that was amazing
right? You didn't need to do anything just
wait and bam, it's faster. But..and we
heard this story already, a couple of times
now right? It's almost ten years since
that article, that our machines are not
getting any faster now, in terms of we're
not having, we don't have machines with
8 GHz, right, the CPUs. We're starting to
have more and more core, so if we actually
want to leverage all the capacity of the
machine, it's not just waiting anymore,
right, we need to change the way you
write software. So, the free lunch is over
And then, other important things happened
for example in 2007, we had the
Programming Erlang book, published by
Pragmatic Programmers, by Joe Armstrong,
which is one of the creators of the
language. And I have it here because it
was when I first started to hear about
Erlang, right. It brought Erlang into
other communities and in particular
it brought it to communities I was
involving with. And then, another event
that happened in this timelines is that
in 2009, Rails, we had a Rails release,
that said that Rails was "threadsafe".
And the reason why they did that, is the
Rails Core Team, they did that, is because
there was, if you were around the Rails
community around that time, you.. there
was a pressure, at that time right, on the
Rails Core Team, exactly that we need to
make Rails threadsafe, exactly because
Rails developers wanted to leverage the
ability of using all the cores on the
machine, and use the machine efficiently.
And one year later, I joined the Rails
Core Team, and I actually found out ah
that Rails was actually not really
"threadsafe", that's why I put it in
between quotes. Because I was constantly
fixing bugs, and there was actually many
reasons, not going to go into details,
that Rails was not actually threadsafe. So
I was working on fixing those bugs, and it
was kind of frustrating, it was kind of
hard, and it was about that time that I
start to put the pieces together, right?
So if I'm doing this work and it feels
hard, it feels frustrating, but I know
that concurrency is becoming more and
more important, and I know that there
are languages like Erlang and many other
languages, that solve this concurrency
well, okay, um, I need to do something,
right? I don't want to, we need to see
ways, I can make this situation better.
And then I started to study, learn, play
with other languages, and throughout this
process, so I was reading many books,
trying to get ideas from different places.
I found this book, 7 Languges in 7 Weeks
by Bruce who'll be speaking later today.
And I was actually familiar with the
majority of the language in the book, but
the thing that really stood out in that
book is that it got languages like Haskell
Scala, Clojure, Erlang, and a few other
more, and it was talking about those
languages, and also their concurrency
models but it was, to me, the book really
put them, like, in separate places, right,
and okay, this the advantages of the
approach, followed by this language,
here are the advantages, here are the
trade-offs. And after I read the book,
what really stood out, was the Erlang
virtual machine. I was saying, I want to
write software that going to run on this
runtime, on this ecosystem, and so that's
the lesson I got from it. And the way I
like to say is that I like it so I went
and bought more books on Erlang, and I
also actually really like Clojure after I
read the book so I went to study Clojure
too. It kinda shows later in the languages
some of our features. And the way I like
to say about when I was studying Erlang,
writing software in Erlang now, trying to
put some things in production, is that
I like it, everything I saw, but I hated
the things I didn't see. Okay, and at
first, the things I didn't see was a
little bit unclear, but I decided okay, so
I want to try my own language, just for
fun, to see if I could get some of those
ideas, some of those things I'm missing,
if I can get it there, and see how it's
going to play out.