ActiveCpp: Active Objects for Modern C++

Login

Topic(s) Covered

About Amir Alavi

Seyed Amir Alavi is an embedded software engineer and control systems researcher passionate about building solutions for IoT, smart grid, industrial control systems, and communication networks. He enjoys utilizing tools like real-time operating systems and embedded Linux, with a keen interest in model-based control system design. During his PhD at Queen Mary University of London, Amir explored distributed multi-agent control systems using wireless communication protocols. He is an active open-source contributor, notably to Riverlane’s Aqueduct platform for quantum experiment management, where he supported development of Aqueduct Core and PyAqueduct, and to ActiveCpp, a C++ framework for real-time embedded systems, enhancing its event-driven Active Object model. Previously, he contributed to control systems for quantum computers at Riverlane. Now at Roku, Amir is excited to support the development of streaming media technologies, helping enhance user experiences.

Home > On-Demand Archives > Talks >

ActiveCpp: Active Objects for Modern C++

Amir Alavi - Watch Now - EOC 2025 - Duration: 31:58

ActiveCpp: Active Objects for Modern C++

Amir Alavi

Get Your Pass Today!

Abstract Test Your Knowledge Questions & Comments (2)

The Active Object design pattern is a concurrency pattern that decouples method execution from method invocation to enhance the responsiveness and scalability of an application. This pattern is particularly useful in scenarios where multiple operations need to be performed concurrently without blocking the main thread of execution.

This talk presents modern methods for the Active Object design pattern, also known as Actor objects, in C++ and introduces activecpp (https://github.com/samiralavi/activecpp), a useful single-header templated library to implement this pattern effectively. Key features of the Active Object design pattern, alongside best practices for low-power embedded systems, are discussed, and the activecpp library is showcased for a typical IoT application on an ESP32-S3 SoC-based devkit.

1 / 4

Please log in or create an account to test your knowledge and see the answers.

What did the speaker identify as the primary advantage of the Active Object (actor) design pattern in embedded C++ systems?

A It decouples method execution from method invocation, letting public APIs be called safely while execution runs in the actor's thread.

B It eliminates the need for any threads — everything runs on a single main loop so concurrency is unnecessary.

C It requires all actors to share a global state protected by mutexes to coordinate behavior.

D It guarantees zero-copy mutable messages so receivers can modify messages in-place across threads.

E It replaces message passing with synchronous RPC to simplify communication.

Which structural characteristic of actors did the speaker highlight as the key mechanism for avoiding locks and race conditions?

A Each actor owns its own data storage and single execution thread, preventing shared-state races and removing the need for locks.

B Actors rely on a global mutex pool to ensure exclusive access to shared state among threads.

C Mailboxes allow multiple consumers to concurrently process the same queue to increase throughput.

D Messages are mutable and the sender can change them while the receiver is processing to reduce copying.

E Actors share memory through a specialized shared-pointer that synchronizes access automatically.

Which of the following scenarios did the speaker explicitly mention as a legitimate reason to avoid using the Active Object design pattern?

A When the device is very tight on memory, because message buffers and immutable messages can consume limited RAM.

B When you need to manage multiple independent components with clear APIs — Active Objects are unsuitable there.

C When you require high-throughput asynchronous messaging — Active Objects can't handle that.

D When every component can be owned by a dedicated thread — so Active Objects are redundant.

E When you want to design the system so each component can be individually tested — Active Objects prevent that.

Which implementation detail of ActiveCPP did the speaker point to as a major contributor to its high message throughput?

A ActiveCPP uses a lock-free multi-producer single-consumer (MPSC) queue to efficiently handle message delivery and preserve send order.

B ActiveCPP relies on OS mutexes and condition variables (blocking queues) to ensure message delivery.

C ActiveCPP uses a single-producer multi-consumer queue allowing multiple actors to dequeue the same mailbox concurrently.

D ActiveCPP requires messages to be mutable for in-place updates to speed up delivery.

E ActiveCPP discards message ordering guarantees to maximize throughput.

M↓ MARKDOWN HELP

italics	surround text with asterisks
bold	surround text with two asterisks
hyperlink	[hyperlink](https://example.com) or just a bare URL
code	surround text with `backticks`
~~strikethrough~~	surround text with ~~two tilde characters~~
quote	prefix with >

Upvotes Newest Oldest

datamstr

Score: 0 | 9 months ago | no reply

Excellent presentation!

Miro

Score: 0 | 9 months ago | no reply

Thank you for your presentation of the Active Object model of computation and the ActiveCpp framework. Having worked with Active Objects for a very long time, I'm really glad to see the interest and appreciation for Active Objects/Actors, especially in embedded systems.

One great benefit of Active Objects that I would add to your summary is the non-blocking, RTC (run-to-completion) event processing model. This is perhaps the most consequential departure from the traditional "shared-state concurrency with blocking" based on the traditional RTOS because blocking is technical debt.

Also, have you considered adding explicit support fo state machines to the ActiveCpp framework? Active Objects and state machines beautifully complement each other. Without state machines, the event-driven code inside Active Objects tends to quickly degenerate into "spaghetti code". At the same time, event-driven state machines precisely need the RTC model of execution.

Login

Topic(s) Covered

About Amir Alavi

ActiveCpp: Active Objects for Modern C++

What did the speaker identify as the primary advantage of the Active Object (actor) design pattern in embedded C++ systems?

Which structural characteristic of actors did the speaker highlight as the key mechanism for avoiding locks and race conditions?

Which of the following scenarios did the speaker explicitly mention as a legitimate reason to avoid using the Active Object design pattern?

Which implementation detail of ActiveCPP did the speaker point to as a major contributor to its high message throughput?

Quiz Complete!

OUR SPONSORS & PARTNERS