This course aims to teach learners the fundamentals of Erlang programming language. By the end of the course, students will be able to understand and apply concepts such as shell commands, modules, syntax in functions, recursion, higher-order functions, errors and exceptions handling, concurrency, multiprocessing, OTP (Open Telecom Platform), building concurrent applications, event handlers, supervisors, OTP applications, releases, sockets, testing with EUnit, ETS (Erlang Term Storage), distributed computing, and Common Test. The course is designed for individuals interested in learning Erlang programming language and developing concurrent and distributed applications. The teaching method includes theoretical explanations, practical examples, and hands-on coding exercises.
Overview
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
- The Shell
- Shell Commands
- Numbers
- Invariable Variables
- Atoms
- Boolean Algebra and Comparison Operators
- Tuples
- Lists
- List Comprehensions
- Bit Syntax
- Binary Comprehensions
- What are modules
- Module Declaration
- Compiling the Code
- More About Modules
- Pattern Matching
- Guards, Guards!
- What the If!?
- In Case ... of
- Which to use?
- Dynamite-strong Typing
- Type Conversions
- To Guard a Data Type
- For Type Junkies
- Hello recursion!
- Length
- Length of Tail Recursion
- More recursive functions
- Quick, Sort!
- More than lists
- Thinking recursively
- Let's get functional
- Anonymous functions
- Maps, filters, folds and more
- 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
- Reverse Polish Notation Calculator
- Heathrow to London
- Won't be too long, promised!
- Records
- Key-Value Stores
- Arrays
- A Set of Sets
- Directed Graphs
- Queues
- End of the short visit
- Don't Panic
- Concepts of Concurrency
- Not Entirely Unlike Linear Scaling
- So long and thanks for all the fish!
- State Your State
- We love messages, but we keep them secret
- Time Out
- Selective Receives
- Links
- It's a Trap!
- Monitors
- Naming Processes
- 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)
- It's The Open Telecom Platform!
- The Common Process, Abstracted
- The Basic Server
- Specific Vs. Generic
- Callback to the Future
- .BEAM me up, Scotty!
- 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?
- Handle This! *pumps shotgun*
- Generic Event Handlers
- It's Curling Time!
- Alert The Press!
- From Bad to Good
- Supervisor Concepts
- Using Supervisors
- Child Specifications
- Testing it Out
- Dynamic Supervision
- 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
- Why Would I Want That?
- My Other Car is a Pool
- The Application Resource File
- The Application Behaviour
- From Chaos to Application
- Library Applications
- From OTP Application to Real Application
- Run App Run
- Included Applications
- Complex Terminations
- Am I an Executable Yet?
- Fixing The Leaky Pipes
- Releases With Systools
- Releases With Reltool
- Recipes
- Released From Releases
- The Hiccups of Appups and Relups
- The 9th Circle of Erl
- Progress Quest
- Making Process Quest Better
- Appup Files
- Upgrading the Release
- IO Lists
- TCP and UDP: Bro-tocols
- UDP Sockets
- TCP Sockets
- More Control With Inet
- Sockserv, Revisited
- Where to go From Now?
- The Need for Tests
- EUnit, What's a EUnit?
- Test Generators
- Fixtures
- Testing Regis
- He Who Knits Eunits
- The Concepts of ETS
- ETS Phone Home
- Meeting Your Match
- You Have Been Selected
- DETS
- A Little Less Conversation, A Little More Action Please
- 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
- Adding More to OTP
- Taking and Failing Over
- The Magic 8-Ball
- Making the Application Distributed
- 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?
- 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
- 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
- A Few Words
- Other Topics
- LYSE as a book
- About This Chapter
- EEP, EEP!
- What Maps Shall Be
- Stubby Legs for Early Releases
- Mexican Standoff
- How This Book Would Be Revised For Maps
- On Time for Time
- How Things Were
- How Things Are (18.0+)
- Time Warp
- How to Survive Time Warps
