Sign In Start Free Trial

C++ Reactive Programming

By : Praseed Pai, Abraham

3 (8)

C++ Reactive Programming

3 (8)

By: Praseed Pai, Abraham

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

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Reactive Programming Model – Overview and History

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

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++

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++

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

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++

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

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

RxCpp – the Key Elements

Observables

Observers and their variants (Subscribers)

Subjects

Schedulers

Operators

Summary

Reactive GUI Programming Using Qt/C++

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

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

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++

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

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

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

3 (8)

5 star

25%

4 star

0

3 star

37.5%

2 star

25%

1 star

12.5%

A word about the Reactive micro-services architecture

We have learned how to write a microservices controller using the C++ REST SDK. Maybe we can say that the server we just implemented can be a microservice instance. In a real-life microservices architecture scenario, there will be multiple services hosted in different boxes (Docker containers or Virtual machines), and microservices controller will access these independently deployed services to cater to the client. The microservice controller will aggregate output from different services to send as a response to the client. A basic architecture for a microservice application is shown in the following diagram:

In the previous diagram, the REST (HTTP) client makes an HTTP call to the microservices controller, which wraps http_listener object. The controller invokes three microservices to retrieve data, and the resultant data...

Search

Your notes and bookmarks