Actor-Oriented Design in LabVIEW Course

Actor-Oriented Design in LabVIEW Course covers how to use the Actor Framework to design and implement scalable, extensible software architectures for LabVIEW applications requiring a high level of concurrency. In this course, you will participate in discussions and work independently and collaboratively to design and build individual actors and to architect an application built with those actors. You will discover how to work in the framework, use inheritance and composition to build highly parallel systems with rich behavior, and test and deploy completed systems.

 

Course Last Release Date or Version Number: 2021

Course Details:

Actor-Oriented Design in LabVIEW Course Outline

Lesson Overview Topics

Actor Framework Fundamentals

Explore a model of computation that promotes concurrency and learn how the Actor Framework evolved from systems of queued message handlers.

  • Challenge of Concurrency
  • Introduction to Actor Design
  • Exploring Actor Framework

Creating Actors

Explore the features of the Actor Framework and learn to build an actor.

  • Creating an Actor
  • Creating UIs: Using Control References
  • Using the Time Delay Message
  • Using Static Nested Actors
  • Adding Helper Loops
  • Overview of Error Handling
  • Using Dynamic Nested Actors
  • Creating UIs: User Events
  • Using Last Ack to Manage Nested Actors

Designing Systems in Actor Framework

Develop an application architecture in the Actor Model that meets a given set of requirements.

  • Overview of Evaporative Cooler
  • Designing an Actor System
  • Improving Your Design
Building Actors through Inheritance

Use inheritance to implement complex behavior in a single actor. Learn how a good inheritance hierarchy simplifies development and promotes reuse.

  • Exploring Inheritance
  • Using Desktop Execution Trace Toolkit with Actor Framework

Exploring Hardware Abstraction Layers

Implement a hardware abstraction layer using actors.

  • Exploring Water Level Controller
  • Overview of Hardware Abstraction Layers

Building Actors through Composition

Build an actor that implements complex behavior by managing a set of nested actors.

  • Building Actors through Composition

Decoupling Actors

Make nested actors reusable by decoupling them from their callers.

  • Overview of the Problem
  • Creating Interfaces
  • Using Abstract Messages
Designing User Interfaces Explore options for adding user interfaces to Actor Framework systems.  
  • Creating a UI through Inheritance
  • Creating a Separate UI Actor
  • Building Interchangeable UIs

Exploring Distributed Systems

Explore the communication infrastructure needed to build Actor Framework systems distributed across several computing targets.

  • Managing the FPGA Interface
  • Host-Target Communication
  • Managing UIs for Multiple Subsystems
  • Other Considerations for Actor Systems

State Pattern Actors

Build an actor that can alter how it responds to messages.

  • Exploring State Pattern
  • Managing State in LabVIEW
  • Managing State in Actor Framework

Advanced Message Handlers

Change how the actor implements message handling.

  • Using Adapter Actors
  • Overriding Receive Message

Integrating Actors in Synchronous Systems

Incorporate actors into procedural applications

  • Calling Actors Synchronously
  • Working in Command/Response Environments
Unit Testing in Actor Framework

Develop a suite of automated tests that prove your actors behave as intended.

  • The Testing Challenge
  • Isolating Actors
  • Creating Unit Tests
  • Analyzing Costs

Get started with Actor-Oriented Design in LabVIEW today