Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Independent

Learn You Some Erlang

via Independent

Go to class Write review
Coursera Ad

Google AI Professional Certificate - Learn AI Skills That Get You Hired

Learn More → Corporate Finance Institute Ad

Finance Certifications Goldman Sachs & Amazon Teams Trust

Learn More →

Overview

Google, IBM & Meta Certificates — All 10,000+ Courses at 40% Off
One annual plan covers every course and certificate on Coursera. 40% off for a limited time.
Get Full Access
Explore the world of Erlang programming through this comprehensive tutorial covering everything from basic syntax to advanced concepts like concurrency, OTP applications, and distributed systems. Learn about functional programming, pattern matching, recursion, error handling, and building robust applications. Dive into topics such as supervision trees, release management, testing with EUnit and Common Test, working with Mnesia database, and understanding type specifications. Gain practical experience by implementing various projects and examples throughout the tutorial, preparing you for real-world Erlang development.

Syllabus

Introduction
  • About this tutorial
  • So what's Erlang?
  • Don't drink too much Kool-Aid
  • What you need to dive in
  • Where to get help
Starting Out
  • The Shell
  • Shell Commands
Starting Out (for real)
  • Numbers
  • Invariable Variables
  • Atoms
  • Boolean Algebra and Comparison Operators
  • Tuples
  • Lists
  • List Comprehensions
  • Bit Syntax
  • Binary Comprehensions
Modules
  • What are modules
  • Module Declaration
  • Compiling the Code
  • More About Modules
Syntax in Functions
  • Pattern Matching
  • Guards, Guards!
  • What the If!?
  • In Case ... of
  • Which to use?
Types (or lack thereof)
  • Dynamite-strong Typing
  • Type Conversions
  • To Guard a Data Type
  • For Type Junkies
Recursion
  • Hello recursion!
  • Length
  • Length of Tail Recursion
  • More recursive functions
  • Quick, Sort!
  • More than lists
  • Thinking recursively
Higher Order Functions
  • Let's get functional
  • Anonymous functions
  • Maps, filters, folds and more
Errors and Exceptions
  • Not so fast!
  • A Compilation of Errors
  • No, YOUR logic is wrong!
  • Run-time Errors
  • Raising Exceptions
  • Dealing with Exceptions
  • Wait, there's more!
  • Try a try in a tree
Functionally Solving Problems
  • Reverse Polish Notation Calculator
  • Heathrow to London
A Short Visit to Common Data Structures
  • Won't be too long, promised!
  • Records
  • Key-Value Stores
  • Arrays
  • A Set of Sets
  • Directed Graphs
  • Queues
  • End of the short visit
The Hitchhiker's Guide to Concurrency
  • Don't Panic
  • Concepts of Concurrency
  • Not Entirely Unlike Linear Scaling
  • So long and thanks for all the fish!
More On Multiprocessing
  • State Your State
  • We love messages, but we keep them secret
  • Time Out
  • Selective Receives
Errors and Processes
  • Links
  • It's a Trap!
  • Monitors
  • Naming Processes
Designing a Concurrent Application
  • Understanding the Problem
  • Defining the Protocol
  • Lay Them Foundations
  • An Event Module
  • The Event Server
  • Hot Code Loving
  • I Said, Hide Your Messages
  • A Test Drive
  • Adding Supervision
  • Namespaces (or lack thereof)
What is OTP?
  • It's The Open Telecom Platform!
  • The Common Process, Abstracted
  • The Basic Server
  • Specific Vs. Generic
Clients and Servers
  • Callback to the Future
  • .BEAM me up, Scotty!
Rage Against The Finite-State Machines
  • What Are They?
  • Generic Finite-State Machines
  • A Trading System Specification
  • Game trading between two players
  • That Was Quite Something
  • Fit for the Real World?
Event Handlers
  • Handle This! *pumps shotgun*
  • Generic Event Handlers
  • It's Curling Time!
  • Alert The Press!
Who Supervises The Supervisors?
  • From Bad to Good
  • Supervisor Concepts
  • Using Supervisors
  • Child Specifications
  • Testing it Out
  • Dynamic Supervision
Building an Application With OTP
  • A Pool of Processes
  • The Onion Layer Theory
  • A Pool's Tree
  • Implementing the Supervisors
  • Working on the Workers
  • Writing a Worker
  • Run Pool Run
  • Cleaning the Pool
Building OTP Applications
  • Why Would I Want That?
  • My Other Car is a Pool
  • The Application Resource File
  • The Application Behaviour
  • From Chaos to Application
  • Library Applications
The Count of Applications
  • From OTP Application to Real Application
  • Run App Run
  • Included Applications
  • Complex Terminations
Release is the Word
  • Am I an Executable Yet?
  • Fixing The Leaky Pipes
  • Releases With Systools
  • Releases With Reltool
  • Recipes
  • Released From Releases
Leveling Up in The Process Quest
  • The Hiccups of Appups and Relups
  • The 9th Circle of Erl
  • Progress Quest
  • Making Process Quest Better
  • Appup Files
  • Upgrading the Release
Buckets Of Sockets
  • IO Lists
  • TCP and UDP: Bro-tocols
  • UDP Sockets
  • TCP Sockets
  • More Control With Inet
  • Sockserv, Revisited
  • Where to go From Now?
EUnited Nations Council
  • The Need for Tests
  • EUnit, What's a EUnit?
  • Test Generators
  • Fixtures
  • Testing Regis
  • He Who Knits Eunits
Bears, ETS, Beets
  • The Concepts of ETS
  • ETS Phone Home
  • Meeting Your Match
  • You Have Been Selected
  • DETS
  • A Little Less Conversation, A Little More Action Please
Distribunomicon
  • Alone in the Dark
  • This is my Boomstick
  • Fallacies of Distributed Computing
  • Dead or Dead Alive
  • My Other CAP is a Theorem
  • Setting up an Erlang Cluster
  • Cookies
  • Remote Shells
  • Hidden Nodes
  • The Walls are Made of Fire and the Goggles do Nothing
  • The Calls from Beyond
  • Burying the Distribunomicon
Distributed OTP Applications
  • Adding More to OTP
  • Taking and Failing Over
  • The Magic 8-Ball
  • Making the Application Distributed
Common Test for Uncommon Tests
  • What is Common Test
  • Common Test Cases
  • Testing With State
  • Test Groups
  • The Meeting Room
  • Test Suites
  • Test Specifications
  • Large Scale Testing
  • Integrating EUnit within Common Test
  • Is There More?
Mnesia And The Art of Remembering
  • What's Mnesia
  • What Should the Store Store
  • From Record to Table
  • Of Schemas and Mnesia
  • Creating Tables for Real
  • Access and Context
  • Reads, Writes, and More
  • Implementing The First Requests
  • Accounts And New Needs
  • Meet The Boss
  • Deleting Stuff, Demonstrated
  • Query List Comprehensions
  • Remember Mnesia
Type Specifications and Erlang
  • PLT Are The Best Sandwiches
  • Success Typing
  • Type Inference and Discrepancies
  • Typing About Types of Types
  • Typing Functions
  • Typing Practice
  • Exporting Types
  • Typed Behaviours
  • Polymorphic Types
  • You're my Type
Conclusion
  • A Few Words
  • Other Topics
  • LYSE as a book
Postscript: Maps
  • About This Chapter
  • EEP, EEP!
  • What Maps Shall Be
  • Stubby Legs for Early Releases
  • Mexican Standoff
  • How This Book Would Be Revised For Maps
Postscript: Time Goes On
  • On Time for Time
  • How Things Were
  • How Things Are (18.0+)
  • Time Warp
  • How to Survive Time Warps

Reviews

Start your review of Learn You Some Erlang

Go to class

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.