C++ reactive programming design concurrent and asynchronous applications using the RxCpp library and modern C++ 17

Learn how to implement the reactive programming paradigm with C++ and build asynchronous and concurrent applications Key Features Efficiently exploit concurrency and parallelism in your programs Use the Functional Reactive programming model to structure programs Understand reactive GUI programming t...

Descripción completa

Detalles Bibliográficos
Otros Autores: Pai, Praseed, author (author), Abraham, Peter, author
Formato: Libro electrónico
Idioma:Inglés
Publicado: Birmingham, England ; Mumbai : Packt 2018.
Edición:1st edition
Materias:
Ver en Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630427706719
Tabla de Contenidos:
  • Cover
  • Title Page
  • Copyright and Credits
  • Packt Upsell
  • Contributors
  • Table of Contents
  • Preface
  • Chapter 1: Reactive Programming Model - Overview and History
  • Event-driven programming model
  • Event-driven programming on X Windows
  • Event-driven programming on Microsoft Windows
  • Event-driven programming under Qt
  • Event-driven programming under MFC
  • Other event-driven programming models
  • Limitations of classical event processing models
  • Reactive programming model
  • Functional reactive programming
  • The key interfaces of a reactive program
  • Pull-versus push-based reactive programming
  • The IEnumerable/IObservable duality
  • Converting events to IObservable&lt
  • T&gt
  • The philosophy of our book
  • Summary
  • Chapter 2: A Tour of Modern C++ and its Key Idioms
  • The key concerns of the C++ programming language
  • Zero cost abstraction
  • Expressivity
  • Substitutability
  • Enhancements to C++ for writing better code
  • Type deduction and inference
  • Uniform initialization of variables
  • Variadic templates
  • Rvalue references
  • Move semantics
  • Smart pointers
  • Lambda functions
  • Functors and Lambdas
  • Composition, currying, and partial function application
  • Function wrappers
  • Composing functions together with the pipe operator
  • Miscellaneous features
  • Fold expressions
  • Variant type
  • Other important topics
  • Range-based for loops and observables
  • Summary
  • Chapter 3: Language-Level Concurrency and Parallelism in C++
  • What is concurrency?
  • Hello World of concurrency (using std::thread)
  • Managing threads
  • Thread launch
  • Thread join
  • Passing arguments into a thread
  • Using Lambdas
  • Ownership management
  • Sharing data between threads
  • Mutexes
  • Avoiding deadlock
  • Locking with std::unique_lock
  • Condition variables
  • A thread-safe stack data structure
  • Summary.
  • Chapter 4: Asynchronous and Lock-Free Programming in C++
  • Task-based parallelism in C++
  • Future and promise
  • std::packaged_task
  • std::async
  • C++ memory model
  • Memory access and concurrency
  • The modification contract
  • Atomic operations and types in C++
  • Atomic types
  • std::atomic_flag
  • std::atomic&lt
  • bool&gt
  • Standard atomic integral types
  • std::atomic&lt
  • T*&gt
  • - pointer arithmetic
  • std::atomic&lt
  • &gt
  • primary class template
  • Memory ordering
  • Sequential consistency
  • Acquire-release ordering
  • Relaxed ordering
  • A lock-free data structure  queue
  • Summary
  • Chapter 5: Introduction to Observables
  • The GoF Observer pattern
  • The limitations of the GoF Observer pattern
  • A holistic look at GoF patterns
  • The OOP programming model and hierarchies
  • A Composite/Visitor pattern for expression processing
  • Flattening the composite for iterative processing
  • Map and filter operations on the list
  • Reversing the gaze for Observables!
  • Summary
  • Chapter 6: Introduction to Event Stream Programming Using C++
  • What is Stream programming model?
  • Advantages of the Stream programming model
  • Applied Stream programming using the Streams library
  • Lazy evaluation
  • A simple Stream program
  • Aggregating values using the Stream paradigm
  • The STL and the Stream paradigm
  • A word about the Streams library
  • Event Stream programming
  • Advantages of Event Stream programming
  • The Streamulus library and its programming model
  • The Streamulus library - a peek into its internals
  • The Streamulus Library - a look into expression processing
  • The spreadsheet Library - a change-propagation engine
  • RaftLib - another Stream-processing library
  • What do these things have to do with Rx programming?
  • Summary
  • Chapter 7: Introduction to Data Flow Computation and the RxCpp Library.
  • The data flow computation paradigm
  • An introduction to the RxCpp library
  • The RxCpp library and its programming model
  • A simple Observable/Observer interaction
  • Filters and Transformations with Observables
  • Streaming values from C++ containers
  • Creating Observables from the scratch
  • Concatenating Observable Streams
  • Unsubscribing from Observable Streams
  • An introduction to marble diagrams for visual representation
  • RxCpp (Stream) Operators
  • The average Operator
  • The Scan Operator
  • Composing Operators through the pipe Operator
  • Working with Schedulers
  • A tale of two Operators - flatmap versus concatmap
  • Other Important Operators
  • A peek into the things we haven't covered yet
  • Summary
  • Chapter 8: RxCpp - the Key Elements
  • Observables
  • What's a Producer?
  • Hot versus Cold Observables
  • Hot Observables
  • Hot Observables and the replay mechanism
  • Observers and their variants (Subscribers)
  • Subjects
  • Schedulers
  • ObserveOn versus SubscribeOn
  • The RunLoop Scheduler
  • Operators
  • Creational Operators
  • Transformation Operators
  • Filtering Operators
  • Combining Operators
  • Error-handling Operators
  • Observable utility Operators
  • Conditional and Boolean Operators
  • Mathematical and Aggregate operators
  • Connectable Observable Operators
  • Summary
  • Chapter 9: Reactive GUI Programming Using Qt/C++
  • A quick introduction to Qt GUI programming
  • Qt object model
  • Signals and slots
  • Event system
  • Event handlers
  • Sending events
  • Meta-object system
  • Hello World - Qt program
  • Qt event model with signals/slots/MOC - an example
  • Creating a custom widget
  • Creating the application dialog
  • Executing the application
  • Integrating the RxCpp library with the Qt event model
  • Qt event filter - a reactive approach
  • Creating the window - setting layouts and alignments.
  • Event type specific observables
  • An introduction to RxQt
  • Summary
  • Chapter 10: Creating Custom Operators in RxCpp
  • Philosophy of Rx operators
  • Chaining stock operators
  • Writing basic RxCpp custom operators
  • Writing an RxCpp operator as a function
  • Writing an RxCpp operator as a Lambda
  • Composing custom RxCpp operators
  • Different genres of custom operators
  • Writing a custom creational operator
  • Writing a custom transformation operator
  • Writing a custom operator that involves Schedulers
  • Writing custom operators that can be chained
  • Using the lift&lt
  • t&gt
  • operator to write a custom operator
  • Converting an arbitrary Lambda to a custom Rx operator
  • Creating a custom RxCpp operator in the library
  • Summary
  • Chapter 11: Design Patterns and Idioms for C++ Rx Programming
  • The OOP and Design patterns movement
  • Key Pattern catalogs
  • The GOF catalog
  • The POSA catalog
  • The Design pattern redux
  • From Design patterns to Reactive programming
  • Flattening the hierarchy to navigate through it
  • From Iterators to Observables
  • The Cell pattern
  • The Active object pattern
  • The Resource Loan pattern
  • The Event bus pattern
  • Summary
  • Chapter 12: Reactive Microservices Using C++
  • The C++ language and web programming
  • The REST programming model
  • The C++ REST SDK
  • HTTP client programming using the C++ REST SDK
  • HTTP server programming using the C++ REST SDK
  • Testing the HTTP server using CURL and POSTMAN
  • The libcurl and the HTTP client programming
  • Kirk Shoop's libCURL Wrapper library
  • The JSON and HTTP protocol
  • The C++ REST SDK-based REST server
  • Invoking REST services using the RxCurl library
  • A word about the Reactive micro-services architecture
  • Fine-grained services
  • Polyglot persistence
  • Independent deployment
  • Service orchestration and choreography.
  • Reactive web service call
  • Summary
  • Chapter 13: Advanced Streams and Handling Errors
  • A short recap of the characteristics of a reactive system
  • RxCpp error and exception handling Operators
  • Executing an action on an error
  • Resuming when an error occurs
  • Retry when an error occurs
  • Cleanup with the finally() Operator
  • Schedulers and error handling
  • Event-based Stream handling - some examples
  • Aggregation based on Stream data
  • Application event handling example
  • Summary
  • Other Books You May Enjoy
  • Index.