Chapter 1: Introduction to Erlang
- Lesson 1: What is Erlang?
- Lesson 2: History and Evolution of Erlang
- Lesson 3: Applications and Use Cases of Erlang
- Lesson 4: Setting Up the Erlang Environment
- Lesson 5: Writing Your First Erlang Program
- Lesson 6: Introduction to Erlang Shell (erl)
- Lesson 7: Working with Erlang’s Interactive Shell
Chapter 2: Variables and Data Types
- Lesson 1: Declaring Variables in Erlang
- Lesson 2: Constants and Atoms
- Lesson 3: Data Types: Integers, Floats, Atoms, Tuples, Lists, Maps, Binaries
- Lesson 4: Boolean Data Type and Boolean Operations
- Lesson 5: Pattern Matching Basics
- Lesson 6: Reserved Keywords in Erlang
Chapter 3: Operators in Erlang
- Lesson 1: Arithmetic Operators
- Lesson 2: Relational and Comparison Operators
- Lesson 3: Logical Operators
- Lesson 4: Bitwise and Shift Operators
- Lesson 5: Assignment and Pattern Matching
- Lesson 6: The = Operator in Erlang
Chapter 4: Control Structures
- Lesson 1: Introduction to Control Flow
- Lesson 2: Conditional Statements (if, case, cond)
- Lesson 3: Pattern Matching in Control Structures
- Lesson 4: Loops in Erlang: recursion instead of for and while
- Lesson 5: List Comprehensions
Chapter 5: Functions and Modules
- Lesson 1: Defining and Calling Functions
- Lesson 2: Anonymous Functions (fun)
- Lesson 3: Higher-Order Functions
- Lesson 4: Function Guards and Clauses
- Lesson 5: Creating and Importing Modules
- Lesson 6: Recursive Functions
Chapter 6: Lists, Tuples and Maps
- Lesson 1: Working with Lists
- Lesson 2: Working with Tuples
- Lesson 3: Working with Maps and Key-Value Storage
- Lesson 4: List Manipulation and Comprehensions
- Lesson 5: Advanced Tuple Operations
Chapter 7: Strings and Binaries
- Lesson 1: Working with Strings in Erlang
- Lesson 2: String Manipulation Functions
- Lesson 3: Using Binaries for Efficient String Storage
- Lesson 4: Regular Expressions in Erlang
Chapter 8: Processes and Concurrency in Erlang
- Lesson 1: Introduction to Erlang Concurrency
- Lesson 2: Creating and Managing Processes
- Lesson 3: Message Passing Between Processes
- Lesson 4: Process Monitoring and Linking
- Lesson 5: Using spawn, self, and receive
Chapter 9: Error Handling and Fault Tolerance
- Lesson 1: Error Handling with try...catch...after
- Lesson 2: The throw, exit, and error Mechanisms
- Lesson 3: Fault-Tolerant Design Principles
- Lesson 4: Supervisors and Process Monitoring
- Lesson 5: Handling Timeouts
Chapter 10: Working with Files
- Lesson 1: Reading from Files
- Lesson 2: Writing to Files
- Lesson 3: Handling File Errors
- Lesson 4: File Processing with Streams
Chapter 1: Modern Erlang Features
- Lesson 1: Overview of New Erlang Features
- Lesson 2: Enhancements in Recent OTP Releases
- Lesson 3: Improved Error Handling Mechanisms
- Lesson 4: New Data Structures and Optimizations
Chapter 2: Distributed Systems with Erlang
- Lesson 1: Introduction to Distributed Computing
- Lesson 2: Setting Up Distributed Erlang Nodes
- Lesson 3: Inter-Node Communication
- Lesson 4: Using gen_server for Distributed Applications
- Lesson 5: Load Balancing in Distributed Erlang
Chapter 3: The Open Telecom Platform (OTP)
- Lesson 1: What is OTP?
- Lesson 2: OTP Behaviors (gen_server, gen_statem, gen_event)
- Lesson 3: Using Supervisors for Fault Tolerance
- Lesson 4: Building an OTP Application
Chapter 4: Working with Databases
- Lesson 1: Connecting Erlang to Databases
- Lesson 2: Using Mnesia (Erlang’s Built-in Database)
- Lesson 3: Working with PostgreSQL, MySQL, and NoSQL Databases
- Lesson 4: Query Optimization Techniques
Chapter 5: Networking and Web Development
- Lesson 1: Introduction to Networking in Erlang
- Lesson 2: Using gen_tcp and gen_udp for Network Programming
- Lesson 3: HTTP Communication with httpc
- Lesson 4: Building a Web Server with Cowboy
- Lesson 5: WebSocket Communication in Erlang
Chapter 6: Preprocessor and Macros in Erlang
- Lesson 1: What is the Erlang Preprocessor?
- Lesson 2: Defining Macros with -define
- Lesson 3: Conditional Compilation with -ifdef and -endif
- Lesson 4: Using Includes and Header Files
Chapter 7: Signal Handling in Erlang
- Lesson 1: Process Termination Signals
- Lesson 2: Handling Unexpected Signals
- Lesson 3: Graceful Shutdown of Erlang Applications
- Lesson 4: Implementing Safe Process Recovery
Chapter 8: Creating and Managing Erlang Libraries
- Lesson 1: How to Create an Erlang Library
- Lesson 2: Managing Dependencies with Rebar3
- Lesson 3: Writing Reusable Modules
- Lesson 4: Packaging and Distributing Erlang Libraries
Chapter 9: Performance Optimization in Erlang
- Lesson 1: Profiling and Debugging Erlang Code
- Lesson 2: Using observer and dbg Tools
- Lesson 3: Memory Management and Garbage Collection
- Lesson 4: Improving Concurrency Performance
Chapter 10: Security in Erlang
- Lesson 1: Encryption and Cryptography in Erlang
- Lesson 2: Secure Communication with SSL/TLS
- Lesson 3: Best Practices for Secure Coding
- Lesson 4: Secure Storage of Credentials
Chapter 11: Testing and Debugging
- Lesson 1: Unit Testing with EUnit
- Lesson 2: Property-Based Testing with PropEr
- Lesson 3: Debugging Techniques in Erlang
- Lesson 4: Using Logging for Troubleshooting
Chapter 12: Building Real-World Applications with Erlang
- Lesson 1: Developing a Real-Time Chat Application
- Lesson 2: Building a Scalable Microservices System
- Lesson 3: Creating a High-Performance API Server
- Lesson 4: Deploying Erlang Applications to the Cloud