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 Details:

Actor-Oriented Design in LabVIEW Course Outline

Lesson Overview Topics
Actor Framework: Fundamentals This lesson introduces the Actor Framework and describes the development challenges that it helps to solve. You will learn about the parts of the Actor Framework.
  • The challenge of concurrency
  • Introduction to Actor Design
  • The Actor Framework
Creating Actors This lesson describes the process for creating new actors.
  • Creating an Actor
  • Creating UIs, Part 1: Using control references
  • Using the time delay message
  • Using static nested Actors
  • Adding Helper loops
  • Error handling basics
  • Using dynamic nested Actors
  • Creating UIs, Part 2: Using events
  • Using last ack to manage nested Actors
Introduction to the Course Project This lesson introduces the course project. You will discuss several possible design approaches for solving that problem.    
  • Description of the Challenge
  • Solving the Design Challenge with traditional LabVIEW
Building Actors Through Inheritance This lesson describes how you can use inheritance to implement complex behavior in a single actor.
  • Building Actors through inheritance
Hardware Abstraction Layers This lesson introduces the concept of the hardware abstraction layer (HAL). You will learn the value of using a HAL in your development and how to implement a HAL using the Actor Framework.
  • What is a HAL?
  • Implementing a HAL
Building Actors Through Composition This lesson describes how you can design an actor that uses other actors to implement complex behavior.
  • Building Actors through composition
Zero Coupling and Abstract Messages This lesson describes how you can send messages from a nested actor to its caller without knowing anything about the caller.
  • What is zero coupling?
  • Using abstract messages
Designing User Interfaces This lesson defines two options for creating user interfaces in the Actor Framework. You will learn to select and implement the best option for the problem at hand.  
  • Adding a UI through inheritance
  • What is Low Coupling
  • Implementing a UI based on Model-View-Controller
Distributed Systems This lesson presents how to design actors for use in distributed systems.
  • Connecting Actors to FPGA Code
  • Connecting Actors on multiple targets
  • Managing UIs for multiple subsystems
State Pattern Actors This lesson describes the state pattern and how you can implement the state pattern using the Actor Framework.  
  • What is the state pattern?
  • Managing state in LabVIEW
  • Managing State in Actor Framework
Advanced Message Handlers This lesson introduces techniques that change how actors handle messages.  You will learn when to consider using each technique.  
  • Creating message filters
  • Redirecting messages
  • Generating Custom Trace events
Actors in Synchronous Systems This lesson presents several techniques for integrating actors into a synchronous system.  
  • What is a Synchronous System?
  • Calling an Actor from a synchronous environment
  • Using Reply Messages
Automated Testing This lesson describes how to design a test harness to perform automated testing on an actor.
  • Automated testing

Get started with Actor-Oriented Design in LabVIEW today