This is a workshop with two agendas. The first is to get you up to speed with the Elixir language and the tooling that surrounds it. We'll see why companies around the world are switching to Elixir (and it's not just for the fantastic Phoenix web framework). And we'll do this by writing code: lots of code. By the end of the day you'll have a multi-user, real-time collaborative app up and running.

But there's a second, secret agenda. I want to introduce you to a different way of thinking about programming: state, objects, functions, concurrency: it's all up for grabs. I'm betting that the day after the workshop you'll find yourself writing code differently. Your code will have less coupling, and it will be easier to change. And it doesn't matter what language you're using.

This is a workshop for programmers: I'll run it as fast as you want, and I won't be shy when it comes from giving my personal (and often controversial) opinions.

We're a generation of programmers who grew up with object orientation and imperative programming. When we transition to languages such as Elixir (and even some modern idioms in JavaScript), some of our old reflexes are no longer appropriate. Others are deeply useful, but in different and surprising ways. So, as we work towards the ideal of "programming by transforming", we mustn't forget to transform our thinking, too.

(ps: reducers are objects...)

We're a generation of programmers who grew up with object orientation and imperative programming. When we transition to languages such as Elixir (and even some modern idioms in JavaScript), some of our old reflexes are no longer appropriate. Others are deeply useful, but in different and surprising ways. So, as we work towards the ideal of "programming by transforming", we mustn't forget to transform our thinking, too.

(ps: reducers are objects...)

We're a generation of programmers who grew up with object orientation and imperative programming. When we transition to languages such as Elixir (and even some modern idioms in JavaScript), some of our old reflexes are no longer appropriate. Others are deeply useful, but in different and surprising ways. So, as we work towards the ideal of "programming by transforming", we mustn't forget to transform our thinking, too.

(ps: reducers are objects...)

RESERVE YOUR SEAT NOW

Elixir is the new hot language among folks who are looking for performance, reliability and scalability. It also helps that its a fun language to use.

If you’re already a programmer, you can pick up most of Elixir in a day. Come and join Dave Thomas (author of Programming Elixir) as we explore the language. We’ll all be coding most of the day as we follow a progression of exercises, each illustrating new features of the language and its environment.

This course has a flexible agenda—we’ll go fast, but were not committed to complete all the material. Instead, the goal is to give you a solid foundation from which to start coding Elixir on your own.

WHAT WILL I LEARN

Topics can include:

• effective use of tools such as IEx and mix
• syntax and semantics of Elixir
• functional programming, transformation, and pattern matching
• structuring projects
• testing
• concurrency, processes, and the actor model
• agents and tasks
• OTP Applications, Supervisors, and Servers
• Phoenix

Bring a laptop with Elixir already installed. Instructions are here: https://elixir-lang.org/install.html

RESERVE YOUR SEAT NOW

Object oriented development turns 50 this year. During that time, hundreds of OO languages have come and gone. And yet, with the exception of Smalltalk and a few research languages, none of them were actually object-oriented.

I think we might now be seeing a revival of the spirit of OO, but it is coming from the functional world. I want to show you how to write OO in Elixir, and how liberating this can be.

Object oriented development turns 50 this year. During that time, hundreds of OO languages have come and gone. And yet, with the exception of Smalltalk and a few research languages, none of them were actually object-oriented.

I think we might now be seeing a revival of the spirit of OO, but it is coming from the functional world. I want to show you how to write OO in Elixir, and how liberating this can be.

In 2002, Secretary of Defense Donald Rumsfeld introduced us to the concepts of known knowns, known unknowns, and unknown unknowns. But he left out Unknown Knowns, things that we know without knowing it. And it turns out that these Unknown Knowns are actually the biggest category of knowledge - tacit knowledge.

As developers, we work with knowledge: knowledge of the problem domain, knowledge of our tools, knowledge of our techniques, and knowledge of each other. So getting good at accumulating tacit knowledge is important.

This talk will look at how we are poorly served by most of the current ways we are taught to be better developers. Can we do better? Only if we stop talking and start showing. Let's see why.