Learn you some Erlang for great good!

Updates for 18.0! Many of them are minor (although incredibly useful) improvements, but there is one major change that is a bit complex that came with this new version: a new time API. The time A...

https://learnyousomeerlang.com/time

Oh hi. It's been a while. This is an add-on chapter, one that isn't yet part of the printed version of Learn You Some Erlang for great good! Why does this exist? Was the printed book a huge steam...

https://learnyousomeerlang.com/maps

Hi everyone who still follows this RSS feed even though the text was marked as done. I'm creating an event there to announce that Learn You Some Erlang for Great Good! is now available as a book ...

https://learnyousomeerlang.com/splash-book

This is LYSE's final and last chapter. In this one, we learn how to use Dialyzer to type check our programs and get a few of static languages' advantages, but with a twist. Dialyzer uses success ...

https://learnyousomeerlang.com/dialyzer

Using Common Test and a TDD-like approach, we learn how to use Mnesia, a database written in Erlang, storing data within your VM. It supports full distribution with replication, storage both in R...

https://learnyousomeerlang.com/mnesia

Common Test from the bottom up. Common Test is a test framework for system testing and unit testing in Erlang, allowing basic tests to distributed tests. This chapter shows the basic functionalit...

https://learnyousomeerlang.com/common-test-for-uncommon-tests

A chapter on how to use the built-in distribution features of OTP applications, allowing for a takeover and failover mechanism to be added to your application.

https://learnyousomeerlang.com/distributed-otp-applications

An introduction to distributed computing in the context of Erlang. Material such as the fallacies of distributed computing and the CAP theorem are taught to the reader in a zombie survival set-up...

https://learnyousomeerlang.com/distribunomicon

ETS is a memory-based database to store any kind of Erlang terms within the VM. We learn how to use it and then optimize our process registry to use it and be faster in general.

https://learnyousomeerlang.com/ets

Because of practical necessities when codebases grow, this chapter shows how to to use EUnit, from its most basic uses to effectively testing some OTP code. This includes running tests, writing t...

https://learnyousomeerlang.com/eunit

Going through socket programming in Erlang. We see how to use TCP and UDP sockets with the gen_udp and gen_tcp modules. Topics seen include rate limiting, IO lists, controlling processes and supe...

https://learnyousomeerlang.com/buckets-of-sockets

Using a clone of Progress Quest written in Erlang, this chapter explains how to safely update the code while it's running, without dropping a single session. This makes use of some of our newly a...

https://learnyousomeerlang.com/relups

This is one of the really obscure while incredibly useful sections of OTP: how to package OTP applications as releases. Making releases with OTP tools is somewhat a black art because the standard...

https://learnyousomeerlang.com/release-is-the-word

We kill a two-month hiatus with two chapters on OTP applications. The first one (Building OTP Applications) aims to show the basic concepts behind OTP applications by packaging our process pool i...

https://learnyousomeerlang.com/building-otp-applications

This chapter lets us make practical use of the OTP behaviours seen so far. We do this by writing a process pool application that will let us handle resources and tasks. We explore ideas behind pr...

https://learnyousomeerlang.com/building-applications-with-otp

Right in time before the Bay Area Erlang Conference, the supervisors make their place in Learn You Some Erlang. We see how to set up an OTP supervisor, the restart strategies available, how to wr...

https://learnyousomeerlang.com/supervisors

Event handlers are one of the most underappreciated behaviours available in OTP (generally only used for alarms and loggers). In this chapter, we see them from a broader angle. We'll be seeing th...

https://learnyousomeerlang.com/event-handlers

Rage Against The Finite-State Machines introduces the reader to the concept of finite-state machines and how they're generalised in the OTP framework. We get to write an asynchronous concurrent p...

https://learnyousomeerlang.com/finite-state-machines

Two new chapters, 'What is OTP?' and 'Clients and Servers'. In the first one, the basic ideas behind the OTP framework are explained through the abstraction of a basic client-server pattern into ...

https://learnyousomeerlang.com/what-is-otp

In this chapter, we write a short concurrent application while reviwing Erlang concurrency primitives: processes, links, monitors, hot code loading and message passing. The process acts as a prim...

https://learnyousomeerlang.com/designing-a-concurrent-application

Errors and Processes might be the last chapter released before Learn You Some Erlang hits its one year mark (see: http://ferd.ca/learn-you-some-erlang-a-year-in.html). Thanks to all dedicated rea...

https://learnyousomeerlang.com/errors-and-processes

This chapter's a bit of an extension on the practical aspects of the Hitchhiker's Guide to Concurrency. New multiprocessing and concurrent aspects of Erlang are seen, including how to hold state ...

https://learnyousomeerlang.com/more-on-multiprocessing

I was a bit slow to produce this chapter, but I'll blame that on my laptop dying on me and playoffs Hockey (watching a game as I'm writing this!) Anyway, this is the first chapter to really talk ...

https://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency

Chances are you now understand the functional subset of Erlang pretty well and could read many programs without a problem. However, I still feel like there's a few things missing. In this last ch...

https://learnyousomeerlang.com/a-short-visit-to-common-data-structures

A new chapter arrives. This one is about putting to practice what was seen in Learn You Some Erlang until now. The problems are borrowed from Learn You A Haskell and are about implementing a Reve...

https://learnyousomeerlang.com/functionally-solving-problems

Erlang being a language built for high reliability, it is natural for it to have exceptions. This chapter focuses on how to handle and raise exceptions in the functional subset of Erlang. I go ov...

https://learnyousomeerlang.com/errors-and-exceptions

Time for another chapter, this time I'm covering higher order functions. I'm showing the syntax of anonymous functions, how to use them. Then, as promised in the recursion chapter, we're going to...

https://learnyousomeerlang.com/higher-order-functions

I've added a new chapter to Learn You Some Erlang. This one's about recursion and tail recursion and explains how to work in a language without looping constructs of any kind. We visit common ope...

https://learnyousomeerlang.com/recursion

The next three chapters of the tutorial are online: Modules, Syntax in Functions and Types (or lack thereof). We'll see how to write modules and the functions that go in them, compile our code fo...

https://learnyousomeerlang.com/content

The first three chapters of the tutorial are online: Introduction, Starting Out and Starting Out (for real). We describe Erlang, install the language and VM, visit basic functions of the shell an...

https://learnyousomeerlang.com/content