Home Page Icon
Home Page
Table of Contents for
Index
Close
Index
by Leonardo Borges
Clojure Reactive Programming
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
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
B. Bibliography
Index
A
Abstract Algebra
about /
Functors
agile board
creating, with Om /
Creating an agile board with Om
state /
The board state
components /
Components overview
lifecycle /
Lifecycle and component local state
component local state /
Lifecycle and component local state
multiple column-view components, creating /
Remaining components
utility functions, adding /
Utility functions
Applicative Functors
about /
Applicative Functors
pure function /
Applicative Functors
fapply function /
Applicative Functors
vararg function /
Applicative Functors
stats, calculating of ages /
Gathering stats about ages
Arrowized FRP
about /
Arrowized FRP
Asteroids
about /
Setting up the project
asynchronous data flow
about /
Asynchronous data flow
asynchronous programming
about /
Asynchronous Compositional Event System (CES)aboutprogramming and concurrency
Automaton
URL /
Arrowized FRP
AWS
using /
Infrastructure automation
EC2 /
Infrastructure automation
RDS /
Infrastructure automation
CloudFormation /
Infrastructure automation
AWS resources dashboard
building /
AWS resources dashboard
building, with CloudFormation /
CloudFormation
building, with EC2 /
EC2
building, with RDS /
RDS
designing /
Designing the solution
stub server, setting up /
Running the AWS stub server
setting up /
Setting up the dashboard project
Observables, creating /
Creating AWS Observables
Observables, combining /
Combining the AWS Observables
user interface, building /
Putting it all together
B
backpressure
about /
Backpressure
sample combinator /
Sample
strategies /
Backpressure strategies
reference link /
Backpressure strategies
Bacon.js
URL /
Functional Reactive Programming
about /
Asynchronous data flow
blocking IO
about /
Futures and blocking IO
buffering
about /
Backpressure
fixed buffer /
Fixed buffer
dropping buffer /
Dropping buffer
sliding buffer /
Sliding buffer
C
catch combinator
about /
Catch
CES
versus FRP /
Asynchronous data flow
versus core.async /
CES versus core.async
Chestnut
URL /
A taste of Reactive Programming
cljs-start
URL /
A respondent application
,
Setting up the project
cljx
URL /
Clojure or ClojureScript?
about /
Clojure or ClojureScript?
Clojure
URL, for documentation /
Application components
futures /
Clojure futures
Clojurescript
about /
ClojureScript and Om
ClojureScript game
project, setting up /
Setting up the project
game entities, creating /
Game entities
implementing /
Putting it all together
user input, modeling as event streams /
Modeling user input as event streams
active keys stream, working with /
Working with the active keys stream
CloudFormation
about /
Infrastructure automation
used, for building AWS resources dashboard /
CloudFormation
describeStacks endpoint /
The describeStacks endpoint
describeStackResources endpoint /
The describeStackResources endpoint
combinators
using /
Combinators and event handlers
complex Web UIs
problems /
The problem with complex web UIs
features /
The problem with complex web UIs
Compositional Event System (CES)
about /
Asynchronous Compositional Event System (CES)aboutprogramming and concurrency
Compositional Event Systems
about /
One more flatmap for the road
concurrency
about /
Asynchronous Compositional Event System (CES)aboutprogramming and concurrency
Contacts application
building /
Building a simple Contacts application with Om
state /
The Contacts application state
project, setting up /
Setting up the Contacts project
components /
Application components
cursors, using /
Om cursors
contacts-app component, creating /
Filling in the blanks
contacts-view component, creating /
Filling in the blanks
contact-summary-view component, creating /
Filling in the blanks
details-panel-view component, creating /
Filling in the blanks
contact-details-view component, creating /
Filling in the blanks
contact-details-form-view component, creating /
Filling in the blanks
contact information, updating /
Filling in the blanks
core.async
about /
core.async
CSP /
Communicating sequential processes
stock market application, rewriting /
Rewriting the stock market application with core.async
error handling /
Error handling
backpressure /
Backpressure
transducers /
Transducers and core.async
features /
Summary
versus CES /
CES versus core.async
core.async channels
using /
Intercomponent communication
CSP
about /
Communicating sequential processes
URL /
Communicating sequential processes
cursors
about /
Om cursors
D
data
fetching, in parallel /
Fetching data in parallel
dataflow programming
about /
Dataflow programming
DataTransfer
reference link /
Utility functions
dc-lib
URL /
Dataflow programming
describeDBInstances endpoint
about /
The describeDBInstances endpoint
describeInstances endpoint
about /
The describeInstances endpoint
describeStackResources endpoint
about /
The describeStackResources endpoint
describeStacks endpoint
about /
The describeStacks endpoint
dropping buffer
about /
Dropping buffer
E
EC2
about /
Infrastructure automation
used, for building AWS resources dashboard /
EC2
describeInstances endpoint /
The describeInstances endpoint
Elm
about /
First-order FRP
URL /
First-order FRP
error handling
about /
Error handling
onError combinator /
OnError
catch combinator /
Catch
retry combinator /
Retry
reference link /
Retry
in core.async /
Error handling
event handlers
using /
Combinators and event handlers
events
about /
Signals and events
F
factory methods
reference link /
Custom Observables
first-order FRP
about /
First-order FRP
fixed buffer
about /
Fixed buffer
Flapjax
about /
Complex GUIs and animations
flatmap
about /
Flatmap and friends
with multiple values /
One more flatmap for the road
ForkJoinPool
URL /
The movies example revisited
using /
Futures and blocking IO
FRP
about /
Functional Reactive Programming
implementation challenges /
Implementation challenges
versus CES /
Asynchronous data flow
FRP, use cases
asynchronous programming /
Asynchronous programming and networking
networking /
Asynchronous programming and networking
complex GUIs /
Complex GUIs and animations
animations /
Complex GUIs and animations
Functional Programming
about /
Lessons from functional programming
function currying
about /
Applicative Functors
Functors
about /
Functors
Option Functor /
The Option Functor
Applicative Functors /
Applicative Functors
futures
about /
Clojure futures
creating, in imminent /
Creating futures
blocking IO /
Futures and blocking IO
G
Graphical User Interfaces (GUIs)
about /
Object-oriented Reactive Programming
H
Haskell
about /
Monads
higher-order FRP
about /
Higher-order FRP
history, Reactive Programming
about /
A bit of history
dataflow programming /
Dataflow programming
object-oriented Reactive Programming /
Object-oriented Reactive Programming
LANguage for Programming Arrays at Random (LANPAR) /
The most widely used reactive program
Observer design pattern /
The Observer design pattern
FRP /
Functional Reactive Programming
higher-order FRP /
Higher-order FRP
I
imminent
about /
Imminent – a composable futures library for Clojure
URL /
Imminent – a composable futures library for Clojure
futures, creating /
Creating futures
combinators, using /
Combinators and event handlers
event handlers, using /
Combinators and event handlers
example /
The movies example revisited
implementation challenges, FRP
first-order FRP /
First-order FRP
asynchronous data flow /
Asynchronous data flow
Arrowized FRP /
Arrowized FRP
incidental complexity
about /
Identifying problems with our current approach
removing, with RxClojure /
Removing incidental complexity with RxClojure
infrastructure automation
problem /
The problem
with AWS /
Infrastructure automation
intercomponent communication
about /
Intercomponent communication
agile board, creating /
Creating an agile board with Om
Iterator interface
about /
Observer – an Iterator's dual
J
Java Interop
URL /
Filling in the blanks
JSPerf
URL /
The problem with complex web UIs
L
LANguage for Programming Arrays at Random (LANPAR)
about /
The most widely used reactive program
lein-cljsbuild
URL /
Clojure or ClojureScript?
about /
Clojure or ClojureScript?
M
macros
reference link /
Game entities
ManagedBlocker
reference link /
Futures and blocking IO
map
about /
The semantics of map
Functors /
Functors
Mimmo Cosenza
URL /
Setting up the Contacts project
minimal CES framework
about /
A minimal CES framework
project, setting up /
Clojure or ClojureScript?
public API, designing /
Designing the public API
tokens, implementing /
Implementing tokens
event streams, implementing /
Implementing event streams
behaviors, implementing /
Implementing behaviors
respondent application, building /
A respondent application
Monad
about /
One more flatmap for the road
Monads
about /
Monads
bind function /
Monads
using /
Monads
example /
Monads
monet
URL /
Setting up the project
N
Netflix
about /
Asynchronous programming and networking
O
object-oriented Reactive Programming
about /
Object-oriented Reactive Programming
Observables
creating /
Creating AWS Observables
combining /
Combining the AWS Observables
observables
creating /
Creating Observables
custom observables, creating /
Custom Observables
manipulating /
Manipulating Observables
Observable Sequences
about /
Asynchronous data flow
Observer design pattern
about /
The Observer design pattern
,
The Observer pattern revisited
Iterator interface /
Observer – an Iterator's dual
Om
about /
ClojureScript and Om
Contacts application, building /
Building a simple Contacts application with Om
agile board, creating /
Creating an agile board with Om
om-start template
URL /
Setting up the Contacts project
Om Project Management /
Creating an agile board with Om
onError combinator
about /
OnError
Option Functor
about /
The Option Functor
use case /
Finding the average of ages
P
Purely Functional Data Structures
about /
Lessons from functional programming
URL /
Lessons from functional programming
R
RDS
about /
Infrastructure automation
used, for building AWS resources dashboard /
RDS
describeDBInstances endpoint /
The describeDBInstances endpoint
React.js
about /
Enter React.js
Functional Programming /
Lessons from functional programming
ReactiveCocoa
URL /
Functional Reactive Programming
about /
Asynchronous data flow
Reactive Extensions (Rx)
about /
Asynchronous data flow
,
Reagi and other CES frameworks
drawbacks /
Reagi and other CES frameworks
Reagi
comparing, with other CES frameworks /
Reagi and other CES frameworks
about /
Reagi and other CES frameworks
respondent application
building /
A respondent application
retry combinator
about /
Retry
Rx
observables, creating /
Creating Observables
observables, manipulating /
Manipulating Observables
flatmap /
Flatmap and friends
RX
error handling /
Error handling
RxClojure
URL /
Creating Observables
RxJava
URL /
Functional Reactive Programming
,
Creating Observables
RxJS
URL /
A taste of Reactive Programming
S
sample combinator
about /
Sample
Scala
about /
Monads
ScheduledThreadPoolExecutor pool /
Building a stock market monitoring application
Semigroups
about /
Functors
signals
about /
Signals and events
sine wave animation
creating /
A taste of Reactive Programming
time, creating /
Creating time
coloring /
More colors
updating /
Making it reactive
enhancing /
Exercise 1.1
sliding buffer
about /
Sliding buffer
stock market application
rewriting, with core.async /
Rewriting the stock market application with core.async
application code, implementing /
Implementing the application code
stock market monitoring application
building /
Building a stock market monitoring application
rolling averages, displaying /
Rolling averages
problems, identifying /
Identifying problems with our current approach
incidental complexity, removing with RxClojure /
Removing incidental complexity with RxClojure
observable rolling averages /
Observable rolling averages
stub server
setting up /
Running the AWS stub server
T
Thread Pool
about /
Fetching data in parallel
tools.namespace
URL /
Implementing event streams
using /
Implementing event streams
transducers
about /
Transducers
reference link /
Transducers
with core.async /
Transducers and core.async
transit
about /
Setting up the dashboard project
URL /
Setting up the dashboard project
Trello
URL /
Intercomponent communication
V
Virtual DOM
about /
Lessons from functional programming
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset