C++ Reactive Programming: Design concurrent and asynchronous applications using the RxCpp library and Modern C++17

Description

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 to make your own applications using Qt Book Description Reactive programming is an effective way to build highly responsive applications with an easy-to-maintain code base. This book covers the essential functional reactive concepts that will help you build highly concurrent, event-driven, and asynchronous applications in a simpler and less error-prone way. C++ Reactive Programming begins with a discussion on how event processing was undertaken by different programming systems earlier. After a brisk introduction to modern C++ (C++17), you'll be taken through language-level concurrency and the lock-free programming model to set the stage for our foray into the Functional Programming model. Following this, you'll be introduced to RxCpp and its programming model. You'll be able to gain deep insights into the RxCpp library, which facilitates reactive programming. You'll learn how to deal with reactive programming using Qt/C++ (for the desktop) and C++ microservices for the Web. By the end of the book, you will be well versed with advanced reactive programming concepts in modern C++ (C++17). What you will learn Understand language-level concurrency in C++ Explore advanced C++ programming for the FRP Uncover the RxCpp library and its programming model Mix the FP and OOP constructs in C++ 17 to write well-structured programs Master reactive microservices in C++ Create custom operators for RxCpp Learn advanced stream processing and error handling Who this book is for If you're a C++ developer interested in using reactive programming to build asynchronous and concurrent applications, you'll find this book extremely useful. This book doesn't assume any previous knowledge of reactive programming. Table of Contents Reactive Programming Model – an Overview and its History A Breeze tour of the Modern C++ Language and Its key Idioms The Language level Concurrency and Parallelism in C++ Lock Free and Asynchronous programming in C++ Introduction to Observables Introduction to Event Stream Programming using C++ An Introduction to data flow computation and the Rxcpp library Rxcpp – the Key Elements Reactive GUI Programming using Qt/C++ Design Patterns and Idioms for C++ Reactive programming Reactive Micro services in C++ Advanced Streams and Handling Errors 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 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 Standard atomic integral types std::atomic – pointer arithmetic std::atomic 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 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