C++ Reactive Programming

C++ Reactive Programming

By : Praseed Pai, Peter Abraham

Buy this Book

C++ Reactive Programming

By: Praseed Pai, Peter Abraham

Buy this Book

Overview of this book

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).

Title Page

Packt Upsell

Contributors

Preface

Free Chapter

Reactive Programming Model – Overview and History

Event-driven programming model

Reactive programming model

Functional reactive programming

The key interfaces of a reactive program

Pull-versus push-based reactive programming

Converting events to IObservable<T>

The philosophy of our book

Summary

A Tour of Modern C++ and its Key Idioms

The key concerns of the C++ programming language

Enhancements to C++ for writing better code

Composing functions together with the pipe operator

Miscellaneous features

Range-based for loops and observables

Summary

Language-Level Concurrency and Parallelism in C++

What is concurrency?

Hello World of concurrency (using std::thread)

Managing threads

Using Lambdas

Sharing data between threads

A thread-safe stack data structure

Summary

Asynchronous and Lock-Free Programming in C++

Task-based parallelism in C++

C++ memory model

Memory access and concurrency

The modification contract

Atomic operations and types in C++

Atomic types

Memory ordering

A lock-free data structure queue

Summary

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

Introduction to Event Stream Programming Using C++

What is Stream programming model?

Applied Stream programming using the Streams library

Lazy evaluation

Event Stream programming

Summary

Introduction to Data Flow Computation and the RxCpp Library

The data flow computation paradigm

An introduction to the RxCpp library

Creating Observables from the scratch

An introduction to marble diagrams for visual representation

RxCpp (Stream) Operators

A peek into the things we haven't covered yet

Summary

RxCpp – the Key Elements

Observables

Observers and their variants (Subscribers)

Subjects

Schedulers

Operators

Summary

Reactive GUI Programming Using Qt/C++

A quick introduction to Qt GUI programming

Hello World – Qt program

Qt event model with signals/slots/MOC – an example

Integrating the RxCpp library with the Qt event model

Summary

Creating Custom Operators in RxCpp

Philosophy of Rx operators

Chaining stock operators

Writing basic RxCpp custom operators

Different genres of custom operators

Writing custom operators that can be chained

Summary

Design Patterns and Idioms for C++ Rx Programming

The OOP and Design patterns movement

Key Pattern catalogs

The Design pattern redux

From Design patterns to Reactive programming

The Cell pattern

The Active object pattern

The Resource Loan pattern

The Event bus pattern

Summary

Reactive Microservices Using C++

The C++ language and web programming

The C++ REST SDK

Testing the HTTP server using CURL and POSTMAN

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

Summary

Advanced Streams and Handling Errors

A short recap of the characteristics of a reactive system

RxCpp error and exception handling Operators

Schedulers and error handling

Event-based Stream handling – some examples

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Chapter 8. RxCpp – the Key Elements

In the previous chapter, we were introduced to the RxCpp library and its programming model. We wrote some programs to understand workings of the library and also covered the most essential elements of the RxCpp library. In this chapter, we will cover, in some depth, the key elements of reactive programming , which includes the following:

Observables
Observers and their variants (Subscribers)
Subjects
Schedulers
Operators

In effect, the key aspects of reactive programming are as follows:

Observables are Streams to which Observers can subscribe for notifications
A Subject is a combination of Observable and Observer
Schedulers execute the Action associated with Operators and help the flow of data from Observables to Observers
Operators are functions that take an Observable and emit another Observable (well, almost!)

C++ Reactive Programming

By : Praseed Pai, Peter Abraham

C++ Reactive Programming

By: Praseed Pai, Peter Abraham

Overview of this book

Related Content you might be interested in

Current Title:

C++ Reactive Programming

.NET Design Patterns

Mastering C++ Programming

Mastering C++ Multithreading

Chapter 8. RxCpp – the Key Elements