Gleam in Depth

A Practical Guide to Building Robust Concurrent Systems

Introduction: Why Learn Gleam?

1. What This Book Covers
2. How to Use This Book
3. Prerequisites
4. A Note on Tone and Approach

Chapter 1: Why Gleam? Philosophy, History and Ecosystem

1. The Problem with Modern Programming
2. Enter Gleam: A Language for Clarity and Reliability
3. History and Origins
4. Design Principles
5. The Gleam Ecosystem Today
6. Who Should Use Gleam and When
7. Comparing Gleam with Related Languages
8. Summary

Chapter 2: Getting Started: Installation, Tooling and Your First Project

1. Installing Gleam and Prerequisites
2. Understanding the Gleam Build Tool
3. Project Structure and Configuration
4. Your First Gleam Program
5. Editor Setup and Development Experience
6. Building and Running Your First Application End-to-End

Chapter 3: Language Fundamentals: Syntax, Types and Functions

1. Program Structure and Module Basics
2. Variables, Constants and Immutability
3. Basic Types
4. Type Inference and Explicit Annotations
5. Functions: Definition, Calls and Arguments
6. Expressions and Statements
7. Summary

Chapter 4: Pattern Matching, Guards and Control Flow

1. The Power of Pattern Matching
2. Case Expressions and Exhaustive Matching
3. Matching on Tuples, Lists and Custom Patterns
4. Guards: Adding Conditions to Patterns
5. Pipelines for Readable Data Flow
6. Recursion as Control Flow
7. Summary

Chapter 5: Data Structures and Custom Types

1. Records: Named Fields and Structured Data
2. Custom Types and Variants
3. Generics: Writing Reusable Type-Safe Code
4. The Result Type: Explicit Error Handling
5. The Option Type: Handling Absence Safely
6. Lists, Tuples, Strings and Dictionaries
7. Summary

Chapter 6: Functional Programming in Gleam

1. Functions as First-Class Values
2. Higher-Order Functions
3. Immutability and Its Consequences
4. Pure Functions and Side Effects
5. Function Composition and Pipeline Design
6. Laziness vs Eager Evaluation in Gleam
7. Summary

Chapter 7: Modules, Organization and Code Structure

1. Module System Fundamentals
2. Imports and Qualified Access
3. Type Exports and Public Interfaces
4. Project Structure for Growing Applications
5. Code Organization Patterns
6. Refactoring and Modularization Strategies
7. Summary

Chapter 8: Error Handling and Robustness

1. Philosophy of Explicit Errors
2. Using Result for Recoverable Errors
3. The Try Operator and Error Propagation
4. Custom Error Types
5. Panic and Unrecoverable Errors
6. Building Fault-Tolerant Components
7. Summary

Chapter 9: Concurrency on the BEAM: Processes, Messages and Actors

1. The BEAM Runtime and Why It Matters
2. Lightweight Processes in Gleam
3. Message Passing: Send and Receive
4. The Actor Pattern in Practice
5. Building Concurrent Systems
6. Concurrency Pitfalls and Best Practices
7. Summary

Chapter 10: OTP Concepts and Production-Concurrent Design

1. What Is OTP and Why Gleam Uses It
2. Supervision Trees: Letting Things Crash
3. Gen_Server in Gleam
4. Fault Tolerance Design
5. Distributed Applications on BEAM
6. Building Resilient Systems: Putting It All Together
7. Summary

Chapter 11: Interoperability: Erlang, Elixir and JavaScript

1. Calling Erlang from Gleam
2. Calling Gleam from Elixir
3. Calling Elixir from Gleam
4. JavaScript Compilation Target
5. JavaScript Interoperability
6. Polyglot BEAM Projects
7. Platform-Specific Code and Conditional Compilation
8. Summary

Chapter 12: The Ecosystem: Packages, Dependencies and Tooling

1. Hex Package Manager and gleam add
2. Creating and Publishing Your Own Package
3. Dependency Management Best Practices
4. The Gleam Build Tool Deep Dive
5. Documentation Generation and Reading Docs
6. Community Libraries and Ecosystem Survey
7. Summary

Chapter 13: Testing, Debugging and Quality Assurance

1. The Gleam Test Framework
2. Writing Effective Tests
3. Property-Based Testing
4. Test Structure and Helpers
5. Debugging Techniques
6. Static Analysis and Linting
7. Continuous Integration for Gleam Projects
8. Summary

Chapter 14: Building Real Applications: Web Services, APIs and Data

1. Web Frameworks in Gleam
2. Building a RESTful JSON API
3. Working with JSON
4. Database Access
5. Networking and HTTP Clients
6. Complete Application Walkthrough Summary
7. Summary

Chapter 15: Performance, Deployment and Production Operations

1. Performance Characteristics of Gleam
2. Memory Behavior and Optimization
3. Profiling and Benchmarking
4. Deployment Options
5. Observability in Production
6. Security Considerations
7. Summary

Chapter 16: Advanced Patterns and Idiomatic Gleam

1. Common Design Patterns in Gleam
2. Domain Modeling with Custom Types
3. Effect Systems and Managed Side Effects
4. Macro Programming and Why Gleam Avoids Them
5. Migration Strategies
6. Building Maintainable Long-Term Gleam Systems
7. Summary

Conclusion: The Future of Gleam and Your Journey Ahead

1. Where Gleam Is Headed
2. The BEAM Ecosystem’s Future Role
3. Your Path Forward as a Gleam Developer
4. Final Thoughts on Simplicity, Reliability and Joy in Programming

References

1. Official Gleam Resources
2. Language Design and History
3. BEAM Runtime and OTP
4. Standard Library
5. Web Development and Frameworks
6. Databases
7. Testing and Tooling
8. Deployment and Operations
9. Community and Learning Resources
10. Comparative and Analytical Sources