Clojure Reactive Programming
Design and Implement Highly Reusable Reactive Applications by Integrating Different Frameworks with Clojure
1. Auflage
Erschienen am 23. März 2015
232 Seiten
978-1-78398-667-5 (ISBN)
Beschreibung
Reactive Programming (RP) is central to many concurrent systems. It endeavors to make the process of developing highly-concurrent, event-driven, and asynchronous applications simpler and less error-prone. RP comes in many flavors and we will look at some of them in this book.Clojure Reactive Programming is a practical guide aimed at exploring RP. It starts by describing Functional Reactive Programming (FRP) and its formulations, as well as how it inspired Compositional Event Systems (CES).It also presents several examples of Reactive applications implemented in different frameworks, allowing you to develop an understanding of the subject as well as learn how to develop your ability to work with time-varying values.By the end of the book, you will be equipped to solve real-world problems as well as understand the trade-offs between the approaches shown in the book.
Alle Preise
Weitere Details
Weitere Ausgaben
Inhalt
- Intro
- Clojure Reactive Programming
- Table of Contents
- Clojure Reactive Programming
- Credits
- About the Author
- Acknowledgments
- About the Reviewers
- www.PacktPub.com
- Support files, eBooks, discount offers, and more
- Why subscribe?
- Free access for Packt account holders
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Errata
- Piracy
- Questions
- 1. What is Reactive Programming?
- A taste of Reactive Programming
- Creating time
- More colors
- Making it reactive
- Exercise 1.1
- A bit of history
- Dataflow programming
- Object-oriented Reactive Programming
- The most widely used reactive program
- The Observer design pattern
- Functional Reactive Programming
- Higher-order FRP
- Signals and events
- Implementation challenges
- First-order FRP
- Asynchronous data flow
- Arrowized FRP
- Applications of FRP
- Asynchronous programming and networking
- Complex GUIs and animations
- Summary
- 2. A Look at Reactive Extensions
- The Observer pattern revisited
- Observer - an Iterator's dual
- Creating Observables
- Custom Observables
- Manipulating Observables
- Flatmap and friends
- One more flatmap for the road
- Error handling
- OnError
- Catch
- Retry
- Backpressure
- Sample
- Backpressure strategies
- Summary
- 3. Asynchronous Programming and Networking
- Building a stock market monitoring application
- Rolling averages
- Identifying problems with our current approach
- Removing incidental complexity with RxClojure
- Observable rolling averages
- Summary
- 4. Introduction to core.async
- Asynchronous programming and concurrency
- core.async
- Communicating sequential processes
- Rewriting the stock market application with core.async
- Implementing the application code
- Error handling
- Backpressure
- Fixed buffer
- Dropping buffer
- Sliding buffer
- Transducers
- Transducers and core.async
- Summary
- 5. Creating Your Own CES Framework with core.async
- A minimal CES framework
- Clojure or ClojureScript?
- Designing the public API
- Implementing tokens
- Implementing event streams
- Implementing behaviors
- Exercises
- Exercise 5.1
- Exercise 5.2
- A respondent application
- CES versus core.async
- Summary
- 6. Building a Simple ClojureScript Game with Reagi
- Setting up the project
- Game entities
- Putting it all together
- Modeling user input as event streams
- Working with the active keys stream
- Reagi and other CES frameworks
- Summary
- 7. The UI as a Function
- The problem with complex web UIs
- Enter React.js
- Lessons from functional programming
- ClojureScript and Om
- Building a simple Contacts application with Om
- The Contacts application state
- Setting up the Contacts project
- Application components
- Om cursors
- Filling in the blanks
- Intercomponent communication
- Creating an agile board with Om
- The board state
- Components overview
- Lifecycle and component local state
- Remaining components
- Utility functions
- Exercises
- Summary
- 8. Futures
- Clojure futures
- Fetching data in parallel
- Imminent - a composable futures library for Clojure
- Creating futures
- Combinators and event handlers
- The movies example revisited
- Futures and blocking IO
- Summary
- 9. A Reactive API to Amazon Web Services
- The problem
- Infrastructure automation
- AWS resources dashboard
- CloudFormation
- The describeStacks endpoint
- The describeStackResources endpoint
- EC2
- The describeInstances endpoint
- RDS
- The describeDBInstances endpoint
- Designing the solution
- Running the AWS stub server
- Setting up the dashboard project
- Creating AWS Observables
- Combining the AWS Observables
- Putting it all together
- Exercises
- Summary
- A. The Algebra of Library Design
- The semantics of map
- Functors
- The Option Functor
- Finding the average of ages
- Applicative Functors
- Gathering stats about ages
- Monads
- Summary
- B. Bibliography
- Index
