Mastering Racket

From First Steps to Language-Oriented Programming

Introduction: Why Racket?

1. The Racket Promise: One Language to Rule Them All
2. Where Racket Shines and Where It Does Not
3. A Brief Tour of What You Will Build
4. How to Read This Book

Chapter 1: Origins and Philosophy

1. From Lisp to Scheme to PLT Scheme to Racket
2. The Homage Report: Designing a Language for Language Design
3. Homoiconicity and Code as Data
4. The Read-Eval-Print Loop and Interactive Development
5. When Racket Is the Right Tool

Chapter 2: Getting Started with Racket

1. Installing Racket on Your System
2. DrRacket: The Integrated Development Environment
3. The REPL and Interactive Exploration
4. Your First Programs: From Hello World to Simple Calculations
5. Project Structure and File Organization

Chapter 3: Expressions, Values and the Language Core

1. S-Expressions: Parentheses as Structure
2. Literals: Numbers, Strings, Characters, Booleans, Symbols
3. Variables, Definitions and Bindings
4. Functions: Definition, Application and Arguments
5. The Evaluation Model: How Racket Computes

Chapter 4: Control Flow and Recursion

1. Conditionals: cond, if, when, unless and case
2. Recursion as the Foundation of Repetition
3. Tail Calls and Efficient Recursion
4. Iteration with map, filter, foldl and foldr
5. Pattern Matching for Structural Decomposition

Chapter 5: Data Structures and Collections

1. Pairs and Lists: The Fundamental Building Blocks
2. Vectors for Indexed Access
3. Strings and Characters in Practice
4. Hash Tables and Sets for Efficient Lookup
5. Choosing the Right Collection for the Job

Chapter 6: Structured Data, Contracts and Safety

1. Defining Structures with struct
2. Accessors, Mutators and Predicates
3. Contracts: Runtime Guarantees Between Modules
4. Structured Error Handling with Exceptions

Chapter 7: Functional Programming in Racket

1. Higher-Order Functions: Functions That Take Functions
2. Closures and Lexical Scoping
3. Immutability and Side Effects
4. Functional Design Patterns in Racket
5. When to Mutate and When Not To

Chapter 8: Modules, Libraries and Organization

1. The Module System: require and provide
2. Creating Your Own Libraries
3. Language Pragmas and #lang Choices
4. Package Management with raco pkg
5. Documentation with Scribble

Chapter 9: Macros and Metaprogramming

1. What Macros Are and Why They Matter
2. Syntax Objects and the Quote/Unquote Model
3. Writing Your First Hygienic Macro
4. Pattern Matching in Macro Definitions
5. Building Domain-Specific Language Constructs

Chapter 10: Object-Oriented Programming in Racket

1. Classes and Objects: The Basics
2. Inheritance and Super Calls
3. Interfaces and Mixins for Flexible Design
4. When to Use OOP in Racket

Chapter 11: Concurrency, Parallelism and Performance

1. Threads and Lightweight Concurrency
2. Synchronization: Semaphores, Channels and Mutual Exclusion
3. Futures and Parallel Computation
4. Parallel Threads in Racket 9.0+
5. Profiling and Performance Tuning
6. Optimizing Hot Paths in Racket

Chapter 12: Input/Output, Files and Networking

1. Ports and Streams for I/O
2. Reading and Writing Files
3. Command-Line Applications with racket/cmdline
4. Networking Basics: TCP and UDP

Chapter 13: Web Development and Databases

1. Building a Web Server with racket/web-server
2. Routing and Request Handling
3. Templates and Dynamic HTML Generation
4. Database Access with DB Libraries
5. A Complete Small Web Application

Chapter 14: GUI Development and Desktop Applications

1. The racket/gui Framework Overview
2. Building Windows and Dialogs
3. Widgets, Layouts and Event Handling
4. A Small Desktop Application Example
5. When GUI Development in Racket Makes Sense

Chapter 15: Language-Oriented Programming and DSLs

1. What Is a Language in Racket?
2. Creating Your Own #lang
3. Custom Readers and Syntax Extensions
4. Building a Practical DSL from Scratch
5. The Philosophy of Language-Oriented Programming

Conclusion: Architectural Guidance and Next Steps

1. Idiomatic Racket Design Principles
2. Project Architecture at Scale
3. Performance and Maintainability Practices
4. Deployment and Distribution Options
5. Further Learning Resources and Community
6. Quick Reference: Key Forms, Functions and Conventions

References