You are previewing Clojure Applied.
O'Reilly logo
Clojure Applied

Book Description

Think in the Clojure way! Once you're familiar with Clojure, take the next step with extended lessons on the best practices and most critical decisions you'll need to make while developing. Learn how to model your domain with data, transform it with pure functions, manage state, spread your work across cores, and structure apps with components. Discover how to use Clojure in the real world, and unlock the speed and power of this beautiful language on the Java Virtual Machine.

Table of Contents

  1. Clojure Applied
    1. For the Best Reading Experience...
    2. Table of Contents
    3. Early praise for Clojure Applied
    4. Foreword
    5. Acknowledgments
    6. Introduction
      1. Putting Clojure to Work
      2. Building Applications
      3. From Build to Deploy
      4. About This Book
      5. Online Resources
    7. Part 1: Foundations
      1. Chapter 1: Model Your Domain
        1. Modeling Entities
        2. Constructing Entities
        3. Modeling Relationships
        4. Validating Entities
        5. Domain Operations
        6. Wrapping Up
      2. Chapter 2: Collect and Organize Your Data
        1. Choosing the Right Collection
        2. Updating Collections
        3. Accessing Collections
        4. Building Custom Collections
        5. Wrapping Up
      3. Chapter 3: Processing Sequential Data
        1. Mapping Values
        2. Reducing to a Value
        3. Filtering and Removing Values
        4. Take and Drop
        5. Sorting and Duplicate Removal
        6. Grouping Values
        7. Putting It All Together
        8. Wrapping Up
    8. Part 2: Applications
      1. Chapter 4: State, Identity, and Change
        1. Modeling a Change
        2. Tools for Managing Change
        3. Living with Change
        4. Wrapping Up
      2. Chapter 5: Use Your Cores
        1. Push Waiting to the Background
        2. Queues and Workers
        3. Parallelism with Reducers
        4. Thinking in Processes
        5. Wrapping Up
      3. Chapter 6: Creating Components
        1. Organizing with Namespaces
        2. Designing Component APIs
        3. Connecting Components with Channels
        4. Implementing Components
        5. Wrapping Up
      4. Chapter 7: Compose Your Application
        1. Taking Things Apart
        2. Implementing with Component
        3. Putting Things Together
        4. System Configuration
        5. Wrapping Up
    9. Part 3: Practices
      1. Chapter 8: Testing Clojure
        1. Interactive REPL Tests
        2. Example-Based Tests with clojure.test
        3. Organizing and Running Your Tests
        4. Example-Based Tests with expectations
        5. Property-Based Tests with test.check
        6. Wrapping Up
      2. Chapter 9: Formatting Data
        1. Data Serialization Formats
        2. Extensible Data Notation
        3. JSON
        4. Transit
        5. Wrapping Up
      3. Chapter 10: Getting out the Door
        1. Publish Your Code
        2. Choose a Deployment Environment
        3. Deploy to a Platform
        4. Provision Your Own Servers
        5. Wrapping Up
    10. Appendix 1: Roots
      1. Reasonability
      2. Lisp
      3. Macros and Metaprogramming
      4. Persistent Data Structures
      5. Lazy and Delayed Evaluation
      6. Futures and Promises
      7. Concurrent Channels
      8. Multiversion Concurrency Control
      9. Wrapping Up
    11. Appendix 2: Thinking in Clojure
      1. Make Reasoned Choices
      2. Be Reasonable
      3. Keep It Simple
      4. Build Just Enough
      5. Compose
      6. Be Precise
      7. Use What Works
      8. Wrapping Up
    12. Bibliography
      1. You May Be Interested In…