Clojure for the Brave and True: Learn the Ultimate Language and Become a Better Programmer

About the Author
About the Technical Reviewer
Brief Contents
Contents in Detail
Foreword
Acknowledgments
Introduction
Learning a New Programming Language: A Journey Through the Four Labyrinths
How This Book Is Organized
Part I: Environment Setup
Part II: Language Fundamentals
Part III: Advanced Topics
The Code
The Journey Begins!
Part I: Environment Setup
Chapter 1: Building, Running,
and the REPL
First Things First: What Is Clojure?
Leiningen
Creating a New Clojure Project
Running the Clojure Project
Building the Clojure Project
Using the REPL
Clojure Editors
Summary
Chapter 2: How to Use Emacs, an Excellent Clojure Editor
Installation
Configuration
Emacs Escape Hatch
Emacs Buffers
Working with Files
Key Bindings and Modes
Emacs Is a Lisp Interpreter
Modes
Installing Packages
Core Editing Terminology and Key Bindings
Point
Movement
Selection with Regions
Killing and the Kill Ring
Editing and Help
Using Emacs with Clojure
Fire Up Your REPL!
Interlude: Emacs Windows and Frames
A Cornucopia of Useful Key Bindings
How to Handle Errors
Paredit
Continue Learning
Summary
Part II: Language Fundamentals
Chapter 3: Do Things: A Clojure Crash Course
Syntax
Forms
Control Flow
Naming Values with def
Data Structures
Numbers
Strings
Maps
Keywords
Vectors
Lists
Sets
Simplicity
Functions
Calling Functions
Function Calls, Macro Calls, and Special Forms
Defining Functions
Anonymous Functions
Returning Functions
Pulling It All Together
The Shire’s Next Top Model
let
loop
Regular Expressions
Symmetrizer
Better Symmetrizer with reduce
Hobbit Violence
Summary
Exercises
Chapter 4: Core Functions in Depth
Programming to Abstractions
Treating Lists, Vectors, Sets, and Maps as Sequences
first, rest, and cons
Abstraction Through Indirection
Seq Function Examples
map
reduce
take, drop, take-while, and drop-while
filter and some
sort and sort-by
concat
Lazy Seqs
Demonstrating Lazy Seq Efficiency
Infinite Sequences
The Collection Abstraction
into
conj
Function Functions
apply
partial
complement
A Vampire Data Analysis Program for the FWPD
Summary
Exercises
Chapter 5: Functional Programming
Pure Functions: What and Why
Pure Functions Are Referentially Transparent
Pure Functions Have No Side Effects
Living with Immutable Data Structures
Recursion Instead of for/while
Function Composition Instead of Attribute Mutation
Cool Things to Do with Pure Functions
comp
memoize
Peg Thing
Playing
Code Organization
Creating the Board
Moving Pegs
Rendering and Printing the Board
Player Interaction
Summary
Exercises
Chapter 6: Organizing Your Project: A Librarian’s Tale
Your Project as a Library
Storing Objects with def
Creating and Switching to Namespaces
refer
alias
Real Project Organization
The Relationship Between File Paths and Namespace Names
Requiring and Using Namespaces
The ns Macro
To Catch a Burglar
Summary
Chapter 7: Clojure Alchemy: Reading, Evaluation, and Macros
An Overview of Clojure’s Evaluation Model
The Reader
Reading
Reader Macros
The Evaluator
These Things Evaluate to Themselves
Symbols
Lists
Macros
Syntactic Abstraction and the -> Macro
Summary
Exercises
Chapter 8: Writing Macros
Macros Are Essential
Anatomy of a Macro
Building Lists for Evaluation
Distinguishing Symbols and Values
Simple Quoting
Syntax Quoting
Using Syntax Quoting in a Macro
Refactoring a Macro and Unquote Splicing
Things to Watch Out For
Variable Capture
Double Evaluation
Macros All the Way Down
Brews for the Brave and True
Validation Functions
if-valid
Summary
Exercises
Part III: Advanced Topics
Chapter 9: The Sacred Art of Concurrent and Parallel Programming
Concurrency and Parallelism Concepts
Managing Multiple Tasks vs. Executing Tasks Simultaneously
Blocking and Asynchronous Tasks
Concurrent Programming and Parallel Programming
Clojure Implementation: JVM Threads
What’s a Thread?
The Three Goblins: Reference Cells, Mutual Exclusion, and Dwarven Berserkers
Futures, Delays, and Promises
Futures
Delays
Promises
Rolling Your Own Queue
Summary
Exercises
Chapter 10: Clojure Metaphysics: Atoms, Refs, Vars, and Cuddle Zombies
Object-Oriented Metaphysics
Clojure Metaphysics
Atoms
Watches and Validators
Watches
Validators
Refs
Modeling Sock Transfers
commute
Vars
Dynamic Binding
Altering the Var Root
Stateless Concurrency and Parallelism with pmap
Summary
Exercises
Chapter 11: Mastering Concurrent Processes with core.async
Getting Started with Processes
Buffering
Blocking and Parking
thread
The Hot Dog Machine Process You’ve Been Longing For
alts!!
Queues
Escape Callback Hell with Process Pipelines
Additional Resources
Summary
Chapter 12: Working with the JVM
The JVM
Writing, Compiling, and Running a Java Program
Object-Oriented Programming in the World’s Tiniest Nutshell
Ahoy, World
Packages and Imports
JAR Files
clojure.jar
Clojure App JARs
Java Interop
Interop Syntax
Creating and Mutating Objects
Importing
Commonly Used Java Classes
The System Class
The Date Class
Files and Input/Output
Resources
Summary
Chapter 13: Creating and Extending Abstractions with Multimethods, Protocols, and Records
Polymorphism
Multimethods
Protocols
Records
Further Study
Summary
Exercises
Appendix A: Building and Developing with Leiningen
The Artifact Ecosystem
Identification
Dependencies
Plug-Ins
Summary
Appendix B: Boot, the Fancy Clojure Build Framework
Boot’s Abstractions
Tasks
The REPL
Composition and Coordination
Handlers and Middleware
Tasks Are Middleware Factories
Filesets
Next Steps
Farewell!
Index
Resources