C++ reactive programming : design concurrent and asynchronous applications using the RxCpp library and modern C++ 17 / Praseed Pai, Peter Abraham.

Format:

Book

Author/Creator:

Pai, Praseed, author.

Abraham, Peter, author.

Language:

English

Subjects (All):

Application software--Development.

Application software.

Physical Description:

1 online resource (319 pages) : illustrations

Edition:

1st edition

Other Title:

C plus plus reactive programming

Place of Publication:

Birmingham, England ; Mumbai : Packt, 2018.

System Details:

text file

Summary:

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. Downloading the example code for this book You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e-mailed directly to you.

Contents:

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

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

T*&gt

- pointer arithmetic

&gt

primary class template

Memory ordering

Sequential consistency

Acquire-release ordering

Relaxed ordering

A lock-free data structure queue

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!

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?

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

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

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

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

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

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

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

Other Books You May Enjoy

Index.

Notes:

Description based on print version record.

ISBN:

9781788624244

1788624246

OCLC:

1044933612