The Joy of Clojure, 2nd Edition, video edition

The Joy of Clojure, 2nd Edition, video edition

by Michael Fogus, Chris Houser
Released May 2014
Publisher(s): Manning Publications
ISBN: None

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

"A cornucopia of programming concepts."
William E. Byrd and Daniel P. Friedman, authors of "The Reasoned Schemer"

The Joy of Clojure, Second Edition is a deep account of the Clojure language. Fully updated for Clojure 1.6, this edition goes beyond the syntax to show you how to write fluent Clojure code. You'll learn functional and declarative approaches to programming and will master techniques that make Clojure elegant and efficient. The book shows you how to solve hard problems related to concurrency, interoperability, and performance, and how great it can be to think in the Clojure way.

The Clojure programming language is a dialect of Lisp that runs on the Java Virtual Machine and JavaScript runtimes. It is a functional programming language that offers great performance, expressive power, and stability by design. It gives you built-in concurrency and the predictable precision of immutable and persistent data structures. And it's really, really fast. The instant you see long blocks of Java or Ruby dissolve into a few lines of Clojure, you'll know why the authors of this book call it a "joyful language." It's no wonder that enterprises like Staples are betting their infrastructure on Clojure.
Inside:

  • Build web apps using ClojureScript
  • Master functional programming techniques
  • Simplify concurrency
  • Covers Clojure 1.6
Michael Fogus and Chris Houser are contributors to the Clojure and ClojureScript programming languages and the authors of various Clojure libraries and language features.

Clojure changes the way we think about programming—this book changes the way we think about Clojure.
Cristofer Weber, NeoGrid

Clear examples for both novice and experienced programmers.
Jasper Lievisse Adriaanse, M:Tier

A joy to read. I couldn't put it down.
Heather Campbell, Kainos

NARRATED BY MARK THOMAS

Table of contents

  1. Part 1. Foundations
    1. Chapter 1. Clojure philosophy
    2. Chapter 1. Clarity
    3. Chapter 1. Why a(nother) Lisp?
    4. Chapter 1. But what’s with all the parentheses?
    5. Chapter 1. Functional programming
    6. Chapter 1. Why Clojure isn’t especially object-oriented
    7. Chapter 1. Most of what OOP gives you, Clojure provides
    8. Chapter 2. Drinking from the Clojure fire hose
    9. Chapter 2. Floating-point numbers
    10. Chapter 2. Putting things together: collections
    11. Chapter 2. Making things happen: calling functions
    12. Chapter 2. Functions with multiple arities
    13. Chapter 2. Locals, loops, and blocks
    14. Chapter 2. Preventing things from happening: quoting
    15. Chapter 2. Using host libraries via interop
    16. Chapter 2. Exceptional circumstances
    17. Chapter 3. Dipping your toes in the pool
    18. Chapter 3. Nil pun with care
    19. Chapter 3. Destructuring with a map
    20. Chapter 3. Using the REPL to experiment
    21. Chapter 3. Putting it all together
  2. Part 2. Data types
    1. Chapter 4. On scalars
    2. Chapter 4. Trying to be rational
    3. Chapter 4. When to use keywords
    4. Chapter 4. Symbolic resolution
    5. Chapter 4. Regular expressions—the second problem
    6. Chapter 5. Collection types
    7. Chapter 5. Sequence terms and what they mean
    8. Chapter 5. Big-O
    9. Chapter 5. Vectors: creating and using them in all their varieties
    10. Chapter 5. Vectors as stacks
    11. Chapter 5. Vectors as map entries
    12. Chapter 5. Lists: Clojure’s code-form data structure
    13. Chapter 5. How to use persistent queues
    14. Chapter 5. Persistent sets
    15. Chapter 5. Thinking in maps
    16. Chapter 5. Putting it all together: finding the position of items in a sequence
  3. Part 3. Functional programming techniques
    1. Chapter 6. Being lazy and set in your ways
    2. Chapter 6. Structural sharing: a persistent toy
    3. Chapter 6. Laziness
    4. Chapter 6. Losing your head
    5. Chapter 6. Putting it all together: a lazy quicksort
    6. Chapter 7. Functional programming
    7. Chapter 7. Higher-order functions
    8. Chapter 7. Pure functions
    9. Chapter 7. On closures
    10. Chapter 7. Sharing closure context
    11. Chapter 7. Thinking recursively
    12. Chapter 7. Tail calls and recur
    13. Chapter 7. Don’t forget your trampoline
    14. Chapter 7. Putting it all together: A* pathfinding
  4. Part 4. Large-scale design
    1. Chapter 8. Macros
    2. Chapter 8. Syntax-quote, unquote, and splicing
    3. Chapter 8. Defining control structures
    4. Chapter 8. Macros combining forms
    5. Chapter 8. Using macros to control symbolic resolution time
    6. Chapter 8. Using macros to manage resources
    7. Chapter 9. Combining data and code
    8. Chapter 9. Expose only what’s needed
    9. Chapter 9. Exploring Clojure multimethods with the Universal Design Pattern
    10. Chapter 9. Ad hoc hierarchies for inherited behaviors
    11. Chapter 9. Types, protocols, and records
    12. Chapter 9. Protocols
    13. Chapter 9. Sharing method implementations
    14. Chapter 9. Building from a more primitive base with deftype
    15. Chapter 9. Clojure implementation
    16. Chapter 10. Mutation and concurrency
    17. Chapter 10. Using refs for a mutable game board
    18. Chapter 10. The things that STM makes easy
    19. Chapter 10. Refactoring with refs
    20. Chapter 10. Vulgar change with ref-set
    21. Chapter 10. When to use agents
    22. Chapter 10. The difference between send and send-off
    23. Chapter 10. When to use atoms
    24. Chapter 10. When to use locks
    25. Chapter 10. Vars and dynamic binding
    26. Chapter 10. Dynamic scope
    27. Chapter 11. Parallelism
    28. Chapter 11. Futures as callbacks
    29. Chapter 11. When to use promises
    30. Chapter 11. Parallel operations
    31. Chapter 11. A brief introduction to reducer/fold
  5. Part 5. Host symbiosis
    1. Chapter 12. Java.next
    2. Chapter 12. A simple dynamic web service
    3. Chapter 12. Anaphoric proxy
    4. Chapter 12. Clojure gen-class and GUI programming
    5. Chapter 12. Clojure’s relationship to Java arrays
    6. Chapter 12. All Clojure functions implement ...
    7. Chapter 12. Using Clojure data structures in Java APIs
    8. Chapter 12. The definterface macro
    9. Chapter 12. Be wary of exceptions
    10. Chapter 12. Handling exceptions
    11. Chapter 13. Why ClojureScript?
    12. Chapter 13. Compiler internals: analysis vs. emission
    13. Chapter 13. Web Audio
    14. Chapter 13. Advanced compilation
    15. Chapter 13. Generating an externs.js file
    16. Chapter 13. Compile vs. run
  6. Part 6. Tangential considerations
    1. Chapter 14. Data-oriented programming
    2. Chapter 14. Common ways to derive information from data
    3. Chapter 14. Data as data
    4. Chapter 14. The benefits of value
    5. Chapter 14. Tagged literals
    6. Chapter 14. Data as code
    7. Chapter 14. Case study: simple event sourcing
    8. Chapter 14. Simulation testing
    9. Chapter 14. Code as data as code
    10. Chapter 14. Putting parentheses around the specification
    11. Chapter 15. Performance
    12. Chapter 15. Transients
    13. Chapter 15. Chunked sequences
    14. Chapter 15. Memoization
    15. Chapter 15. Understanding coercion
    16. Chapter 15. Reducibles
    17. Chapter 15. More reducing function transformers
    18. Chapter 15. Performance of reducibles
    19. Chapter 15. The fold function: reducing in parallel
    20. Chapter 16. Thinking programs
    21. Chapter 16. A brute-force Sudoku solver
    22. Chapter 16. Thinking data via unification
    23. Chapter 16. Substitution
    24. Chapter 16. An introduction to core.logic
    25. Chapter 16. Subgoals
    26. Chapter 16. Constraints
    27. Chapter 16. Solving Sudoku with finite domains
    28. Chapter 17. Clojure changes the way you think
    29. Chapter 17. Implementing a SQL-like DSL to generate queries
    30. Chapter 17. Testing
    31. Chapter 17. Contracts programming
    32. Chapter 17. Invisible design patterns
    33. Chapter 17. Clojure’s first-class design patterns
    34. Chapter 17. Iterator pattern
    35. Chapter 17. Error handling and debugging
    36. Chapter 17. Debugging

Product information

  • Title: The Joy of Clojure, 2nd Edition, video edition
  • Author(s): Michael Fogus, Chris Houser
  • Release date: May 2014
  • Publisher(s): Manning Publications
  • ISBN: None