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.