Index

A

• abstract syntax tree (AST) / The data flow computation paradigm
• acquire-release ordering / Acquire-release ordering
• active object pattern / The active object pattern
• ActiveX Template Library (ATL) / Event-driven programming under MFC
• adaptive communication environment (ACE) / The OOP and design patterns movement
• aggregate operator / Mathematical and aggregate operators
• Applicative-order evaluation (AO) / Lazy evaluation
• applied stream programming
  • Streams library, using / Applied Stream programming using the Streams library
• atomic operations
  • about / Atomic operations and types in C++
  • store operations / Atomic types
  • load operations / Atomic types
  • read-modify-write operations / Atomic types
• atomic types
  • about / Atomic operations and types in C++, Atomic types
  • atomic_flag / std::atomic_flag
  • std / std::atomic<bool>
  • atomic / std::atomic<bool>
  • standard atomic integral types / Standard atomic integral types
  • pointer arithmetic / std::atomic<T*> – pointer arithmetic
  • primary class template / std::atomic<> primary class template
• average operator / The average operator

B

• boolean operators / Conditional and Boolean operators

C

• C++ programming language
  • concerns / The key concerns of the C++ programming language
  • zero cost abstraction / Zero cost abstraction
  • expressivity / Expressivity
  • substitutability / Substitutability
  • enhancements, for writing better code / Enhancements to C++ for writing better code
  • type deduction / Type deduction and inference
  • inference / Type deduction and inference
  • variables uniform initialization / Uniform initialization of variables
  • variadic templates / Variadic templates
  • RValue references / Rvalue references 
  • semantics / Move semantics
  • pointers / Smart pointers
  • lambda functions / Lambda functions
  • lambdas / Functors and Lambdas
  • functors / Functors and Lambdas
  • composition / Composition, currying, and partial function application
  • currying / Composition, currying, and partial function application
  • partial function application / Composition, currying, and partial function application
  • function wrappers / Function wrappers
• C++ REST SDK
  • about / The C++ REST SDK
  • used, for HTTP client programming / HTTP client programming using the C++ REST SDK
  • used, for HTTP Server programming / HTTP server programming using the C++ REST SDK
• C++ REST SDK-based REST Server / The C++ REST SDK-based REST server
• cell pattern / The cell pattern
• compare-and-swap (CAS) / std::atomic<bool>
• Composite pattern
  • used, for expression processing / A Composite/Visitor pattern for expression processing
• concept / The GoF Observer pattern
• concurrency / What is concurrency?, Memory access and concurrency
  • Hello World example / Hello World of concurrency (using std::thread)
• conditional operators / Conditional and Boolean operators
• condition variables / Condition variables
• Connectable Observable operators / Connectable Observable operators
• creational operators / Creational operators
• CURL
  • used, for testing HTTP server / Testing the HTTP server using CURL and POSTMAN

D

• data flow computation paradigm / The data flow computation paradigm
• deadlock
  • avoiding / Avoiding deadlock
• design pattern redux / The design pattern redux
• design patterns
  • about / The OOP and design patterns movement
  • migrating, to reactive programming / From design patterns to reactive programming
• Domain Specific Embedded Language (DSEL) / The philosophy of our book, The Streamulus library and its programming model

E

• Error-Handling operators / Error-handling operators
• error handling / Schedulers and error handling
• event-based Stream handling
  • about / Event-based Stream handling – some examples
  • aggregation, based on Stream data / Aggregation based on Stream data
  • application event handling, example / Application event handling example
• event-driven programming model
  • about / Event-driven programming model
  • on X Windows / Event-driven programming on X Windows
  • on Microsoft Windows / Event-driven programming on Microsoft Windows
  • with Qt / Event-driven programming under Qt
  • MFC / Event-driven programming under MFC
  • alternatives / Other event-driven programming models
  • limitations / Limitations of classical event processing models
• event bus pattern
  • about / The event bus pattern
  • producers / The event bus pattern
  • consumers / The event bus pattern
  • controllers / The event bus pattern
• event filter
  • URL / Qt event filter – a reactive approach
• Event Stream programming
  • about / Event Stream programming
  • advantages / Advantages of Event Stream programming
  • Streamulus library / The Streamulus library and its programming model, The Streamulus library – a peek into its internals, The Streamulus Library – a look into expression processing
  • spreadsheet Library / The spreadsheet Library — a change-propagation engine
  • RaftLib / RaftLib – another Stream-processing library
  • Rx programming / What do these things have to do with Rx programming?
• exception handling operators
  • about / RxCpp error and exception handling operators
  • action, executing on error / Executing an action on an error
  • resuming, on error occurrence / Resuming when an error occurs
  • retry option / Retry when an error occurs
  • cleaning up, with finally() operator / Cleanup with the finally() operator

F

• filter operation
  • applying, on list / Map and filter operations on the list
• flat map operator
  • versus concat map operator / A tale of two operators – flat versus concat map
• fold expressions / Fold expressions
• functional reactive programming (FRP) / Functional reactive programming
• functions
  • composing, with pipe operator / Composing functions together with the pipe operator
• future / Future and promise

G

• Gang of Four (GoF) / The OOP and design patterns movement, GOF patterns
• GoF Observer pattern
  • about / The GoF Observer pattern
  • limitations / The limitations of the GoF Observer pattern

H

• hierarchy
  • about / The OOP programming model and hierarchies
  • flattening / Flattening the hierarchy to navigate through them
• hot Observables
  • versus cold Observables / Hot versus cold Observables
  • about / Hot Observables, Aggregation based on Stream data
  • replay mechanism / Hot Observables and the replay mechanism
• HTTP protocol / The JSON and HTTP protocols
• HTTP server
  • testing, with CURL / Testing the HTTP server using CURL and POSTMAN
  • testing, with POSTMAN / Testing the HTTP server using CURL and POSTMAN
  • LibCurl / The libcurl and the HTTP client programming
  • HTTP client programming / The libcurl and the HTTP client programming
  • CURL Wrapper library, Kirk Shoop / Kirk Shoop's CURL Wrapper library

I

• IObservable<T>
  • events, converting / Converting events to IObservable<T>
• iterative processing
  • composite, flattening / Flattening the composite for iterative processing
• iterator pattern
  • migrating, to observables / From iterators to observables

J

• JavaScript Object Notation (JSON) / The REST programming model, The JSON and HTTP protocols

L

• Lambda function
  • using / Using Lambdas
  • ownership management / Ownership management
• lazy evaluation
  • about / Lazy evaluation
  • Stream program / A simple Stream program
  • values, aggregating with stream paradigm / Aggregating values using the Stream paradigm
  • STL / The STL and the Stream paradigm
  • Streams library / A word about the Streams library
• linearizability
  • URL / Memory access and concurrency
• lock-free data structure / A lock-free data structure  queue

M

• map operation
  • applying, on list / Map and filter operations on the list
• marble diagrams
  • using, for representation / An introduction to marble diagrams for visual representation
• mathematical operator / Mathematical and aggregate operators
• memory access / Memory access and concurrency
• memory model / C++ memory model
• memory ordering
  • about / Memory ordering
  • sequential consistency / Sequential consistency
  • acquire-release ordering / Acquire-release ordering
  • relaxed ordering / Relaxed ordering
• Meta Object Compiler (MOC) / Event-driven programming under Qt, Qt object model
• modification contract / The modification contract
• modification order consistency / Relaxed ordering
• mutexes / Mutexes

N

• Normal-order evaluation (NO) / Lazy evaluation

O

• object-oriented programming (OOP) / The OOP programming model and hierarchies, The OOP and design patterns movement
• object management group (OMG) / The OOP and design patterns movement
• Observables
  • gaze, reversing / Reversing the gaze for Observables!
  • filters / Filters and transformations with Observables
  • transformations / Filters and transformations with Observables
  • creating, from scratch / Creating Observables from scratch
  • Streams, concatenation / Concatenating Observable Streams
  • Streams, unsubscribing / Unsubscribing from Observable Streams
  • about / Observables
  • producer / What's a producer?
  • hot Observables, versus cold Observables / Hot versus cold Observables
  • hot Observables / Hot Observables
  • hot Observables, replay mechanism / Hot Observables and the replay mechanism
• Observable Utility Operators / Observable utility operators
• operators
  • about / Operators
  • creational operators / Creational operators
  • transformation operators / Transformation operators
  • filtering / Filtering operators
  • combining / Combining operators
  • Error-Handling / Error-handling operators
  • Observable Utility Operators / Observable utility operators
  • conditional operators / Conditional and Boolean operators
  • boolean operators / Conditional and Boolean operators
  • aggregate operators / Mathematical and aggregate operators
  • mathematical operators / Mathematical and aggregate operators
  • Connectable Observable operators / Connectable Observable operators

P

• pattern catalogs
  • about / Key pattern catalogs
  • GOF patterns / GOF patterns
  • POSA catalog / POSA catalog
• Patterns of Software Architecture (POSA) / POSA catalog
• pipe operator
  • functions, composing / Composing functions together with the pipe operator
• pointer arithmetic / std::atomic<T*> – pointer arithmetic
• Polyglot programming / Polyglot persistence
• POSTMAN
  • used, for testing HTTP server / Testing the HTTP server using CURL and POSTMAN
• primary class template / std::atomic<> primary class template
• producers / What's a producer?
• promise / Future and promise
• pull method / The design pattern redux
• push-based reactive program
  • versus pull-based reactive program / Pull-versus push-based reactive programming
  • IEnumerable/IObservable duality / The IEnumerable/IObservable duality

Q

• Qt
  • URL / Hello World – Qt program
• Qt event model
  • with signals / Qt event model with signals/slots/MOC – an example
  • with MOC / Qt event model with signals/slots/MOC – an example
  • custom widget, creating / Creating a custom widget
  • application dialog, creating / Creating the application dialog
  • application, executing / Executing the application
  • RxCpp library, integrating / Integrating the RxCpp library with the Qt event model
  • event filter / Qt event filter – a reactive approach
  • window, creating / Creating the window – setting layouts and alignments
  • event type specific observables / Event type specific observables
  • RxQt library / An introduction to RxQt
• Qt GUI programming
  • about / A quick introduction to Qt GUI programming
  • Qt object model / Qt object model
  • signals and slots / Signals and slots
  • event system / Event system
  • event handlers / Event handlers
  • meta-object system / Meta-object system
• Qt object model
  • features / Qt object model
• Qt program / Hello World – Qt program

R

• race condition / Sharing data between threads
• RaftLib
  • about / RaftLib – another Stream-processing library
  • URL / RaftLib – another Stream-processing library
• range-based
  • for loops / Range-based for loops and observables
  • for observables / Range-based for loops and observables
• reactive manifesto
  • URL / A short recap of the characteristics of a reactive system
• Reactive Microservices Architecture
  • about / A word about the Reactive microservices architecture
  • fine-grained services / Fine-grained services
  • Polyglot persistence / Polyglot persistence
  • independent deployment / Independent deployment
  • service orchestration / Service orchestration and choreography
  • web service call / Reactive web service call
• reactive program
  • interfaces / The key interfaces of a reactive program
• reactive programming model / Reactive programming model
• reactive system
  • responsive / A short recap of the characteristics of a reactive system
  • resilient / A short recap of the characteristics of a reactive system
  • elastic / A short recap of the characteristics of a reactive system
  • message-driven / A short recap of the characteristics of a reactive system
• relaxed ordering / Relaxed ordering
• Resource Acquisition Is Initialization (RAII)
  • about / Mutexes
  • URL / Mutexes
• resource loan pattern / Resource loan pattern
• REST programming model / The REST programming model
• REST services
  • invoking, with RxCurl library / Invoking REST services using the RxCurl library
• RxCpp (Stream) operators
  • about / RxCpp (Stream) operators
  • average operator / The average operator
  • scan operator / The scan operator
  • operators, composing through pipe operator / Composing operators through the pipe operator
  • Schedulers, working with / Working with Schedulers
  • flat map, versus concat map / A tale of two operators – flat versus concat map
  • operators / More operators that are of importance
• RxCpp error / RxCpp error and exception handling operators
• RxCpp library
  • about / An introduction to the RxCpp library
  • URL / An introduction to the RxCpp library
  • programming model / The RxCpp library and its programming model
  • simple Observable interaction / A simple Observable/Observer interaction
  • filters, with Observables / Filters and transformations with Observables
  • transformations, with Observables / Filters and transformations with Observables
  • values, streaming from C++ containers / Streaming values from C++ containers
  • integrating, with Qt event model / Integrating the RxCpp library with the Qt event model
• RxCurl library
  • used, for invoking REST services / Invoking REST services using the RxCurl library
• RxQt library / An introduction to RxQt

S

• scan operator / The scan operator
• schedulers
  • working with / Working with Schedulers
  • about / Schedulers, Schedulers and error handling
  • ObserveOn, versus SubscribeOn / ObserveOn versus SubscribeOn
  • RunLoop scheduler / The RunLoop Scheduler
• sequential consistency / Sequential consistency
• signals and slots
  • about / Signals and slots
  • URL / Signals and slots
• spurious failure / std::atomic<bool>
• standard template library (STL) / Applied Stream programming using the Streams library
• std / std::atomic<bool>
• stream programming model
  • about / What is Stream programming model?
  • advantages / Advantages of the Stream programming model
• subjects / Subjects
• subscribers / Observers and their variants (subscribers)

T

• task-based parallelism
  • about / Task-based parallelism in C++
  • future / Future and promise
  • promise / Future and promise
  • packaged_task / std::packaged_task
  • async, using / std::async
• task continuation / HTTP client programming using the C++ REST SDK
• thread-safe stack data structure / A thread-safe stack data structure
• threads
  • managing / Managing threads
  • launching / Thread launch
  • join() / Thread join
  • arguments, passing / Passing arguments into a thread
  • data, sharing between / Sharing data between threads
  • mutexes / Mutexes
  • deadlock, avoiding / Avoiding deadlock
  • unique_lock, used for locking / Locking with std::unique_lock
  • condition variables / Condition variables
• transformation operators / Transformation operators

U

• user-defined type (UDT) / std::atomic<> primary class template

V

• variant type / Variant type
• visitor pattern
  • used, for expression processing / A Composite/Visitor pattern for expression processing

W

• web programming
  • about / The C++ language and web programming
  • REST programming model / The REST programming model