Welcome to Proto.Actor Bootcamp. It is a free course for self-study.
This training course consists of nine main parts, during which you will learn how to create fully functional, real-world programs using Proto.Actor actors and many other components of the Proto.Actor Framework.
We will start with the basics of actors and gradually approach more complex examples.
This course is for self-study — you can do it at any pace you like.
What will you learn from this course
In this course, you will learn how to use Proto.Actor Flamework to create reactive, parallel systems. You will learn how to develop applications that seemed impossible or very complicated before learning Proto.Actor Flamework. After this course, you will feel more confident in solving large and complex tasks.
Module 1: Introduction to Actor Model and Proto.Actor
In the first module, we will give the basic definitions of the actor model and the Proto.Actor Framework:
- Why use the actor model.
- Types of applications for which actors are suitable.
- Use of Proto.Actor in different types of applications.
- The Reactive Manifesto
- Key features of the Proto.Actor.
- Actors and messages.
- What’s an actor in Proto.Actor.
- What’s a message in Proto.Actor.
- What’re Props, RootContext, and ActorContext in Proto.Actor.
- Overview of the supervisor hierarchy in Proto. Actor.
- Installing Proto.Actor.
Module 2 Defining and using actors and messages.
In the previous module, we learned the basic concepts of the actors model and messages. In this chapter, we will study these concepts in more detail. You will learn how to use actors and messages in your applications.:
- Defining Actors.
- Actor References.
- Defining Messages.
- Types of Message Sending.
- Actor Instantiation.
- Defining Which Messages an Actor will processing.
- Sending a Custom Message.
Module 3 Understanding Actor Lifecycles and states.
From this module, you will learn about the actors’ life cycle, and also the internal state of the actor.
- Actor Lifecycle.
- Actor Lifecycle Messages.
- Terminating Actors and Hierarchy of Actors
- What is the Poison Pill message and how to work with it..
- Switchable Actor Behavior
- Refactoring with using behavior switching .
Module 4 Creating actor hierarchy and error handling.
In this module, you will learn how to create a self-recovering system.
- Supervisor and actor hierarchy.
- Overview of the application that demonstrates the supervisor’s capabilities and the actors hierarchy.
- Actor’s address and PID.
- Creating UserCoordinatorActor.
- Creating MoviePlayCounterActor.
- How parent actors are watching over their children actors.
- Strategies to control the state of children’s actors.
Module 5 Message Routing
In this part of our course, you will learn how to quickly and easily solve the scalability problem in your application with routers.
- Router pattern.
- Load balancing with Proto.Actor routers.
- Pool Router.
- Group Router.
- ConsistentHashing Router.
- Implementation of the router pattern with using actors.
Module 6 Message channels
In this module, you will learn about the different types of channels that used to send messages between actors.
- Channels Types.
- Point-to-point Channel.
- Publisher/Subscriber Channel.
- DeadLetter Channel.
- Guaranteed delivery.
Module 7 Proto.Actor Remote
Here we will see how to create a distributed application that runs on multiple computers or virtual machines. You’ll see how Proto.Actor helps you accomplish this most complex task:
- What is horizontal scaling.
- Overview Proto.Actor Remote.
- Example of working with Proto.Actor Remote.
Module 8 Proto.Actor Cluster
In module 8, you learned how to create distributed applications with a fixed number of nodes. The static membership approach is simple but does not have a ready-made load balancing solution or fault tolerance. A cluster allows you to dynamically increase and decrease the number of nodes used by a distributed application, eliminating the fear of having a single point of failure:
- Why do you need clusters.
- Membership in the cluster..
- Joining to the cluster.
- Processing tasks in the Cluster.
- Running a Cluster.
- How to distribute tasks by using routers.
- Reliable task processing.
- Cluster Testing.
Module 9 Persistence Actor
The actor state contained in RAM will be lost when the actor will be stopping or restarting or when the actor system will be stopped or restarted. In this chapter, we will show you how to save this state using the Proto.Actor Persistence module:
How to get started
Here’s how the Proto.Actor Bootcamp works.
Use Github to Make Life Easy
This Github repository contains Visual Studio solution files and other assets you will need to complete the bootcamp.
Thus, if you want to follow the bootcamp we recommend doing the following:
- Sign up for Github, if you haven’t already.
- Fork this repository and clone your fork to your local machine.
- As you go through the project, keep a web browser tab open to the Proto.Actor Bootcamp so you can read all of the instructions clearly and easily.
When you’re doing the lessons…
A few things to bear in mind when you’re following the step-by-step instructions::
- Don’t just copy and paste the code shown in the lesson’s README. You will memorize and learn all the built-in Proto.Actor functions if you will typewriter this code yourself. Kinesthetic learning FTW!
- Don’t be afraid to ask questions. You can reach the Proto.Actor team and other Proto.Actor users in our Gitter chat here.
We will provide explanations of all key concepts throughout each lesson, but of course, you should bookmark (and feel free to use!) the Proto.Actor Docs
Tools / prerequisites
This course expects the following:
- You have some programming experience and familiarity with C#
- A Github account and basic knowledge of Git.
- You are using a version of Visual Studio ( it’s free now!)