Gain insights into using Modern C++ for embedded programming. Learn about safety-critical systems, optimize performance, manage limited resources, and handle parallel execution effectively.

waleed1.tar.gz

C++11

C++ 17

Embedded Programming with Modern C++  is highly valuable for each professional programmer.

In the past, embedded and system programming have had their pitfalls, but modern C++ has been designed to be a better language for this type of development, addressing the previous pitfalls/requirements explicitly. What are these requirements? Embedded systems deal with safety-critical systems, meaning they must guarantee high performance combined with limited resources, while also working in parallel.

The scope of this course goes beyond just embedded programming. Developers who write servers, games, or trading systems may especially benefit from this course because they also have to deal with safety-critical systems, high performance, reduced resources, and parallel execution in their jobs.

To get the most out of the course, you only need a basic understanding of C++. Building off this understanding, this course goes over all the essentials of embedded programming with Modern C++.

Let's get started!

Embedded Programming with Modern C++

## Introduction
`std::async` behaves similar to an asynchronous function call. This function call takes a _**callable**_ together with its arguments. `std::async` is a variadic template and can, therefore, take an arbitrary number of arguments. The call to `std::async` returns a future object `fut`. That's your handle for getting the result via `fut.get()`.

>🔑 **std::async should be your first choice**
>
>The C++ runtime decides if `std::async` is executed in a separate thread. The decision of the C++ runtime may depend on the available number of CPU cores, the utilization of your system, or the size of your work package. By using `std::async`, you only specify the task that will run. The C++ runtime automatically manages the creation and the lifetime of the thread. 


### Eager or Lazy Evaluation
Optionally, you can specify a launch policy for `std::async`.

With the launch policy, you can explicitly specify whether the asynchronous call should be executed in the same thread (`std::launch::deferred`) or in another thread (`std::launch::async`).
 

> **Eager versus lazy evaluation**
>
> Eager and lazy evaluations are two orthogonal strategies to calculate the result of an expression. In the case of [eager evaluation](https://en.wikipedia.org/wiki/Eager_evaluation), the expression will be evaluated immediately - in the case of [lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation), the expression will only be evaluated if needed. Eager evaluation is often called **greedy evaluation**, and lazy evaluation is often called **call-by-need**. With lazy evaluation, you save time and compute power as there is no evaluation on suspicion. 

By default, the launch policy of `std::async` is `std::launch::async` | `std::launch::deferred`, meaning that the system determines if it will execute the work package eagerly or lazily.

What is special about the call `auto fut= std::async(std::launch::deferred, ... )` is that the promise will not be executed immediately. The call `fut.get()` starts the promise lazily, meaning that the promise will only run if the future asks for the result via `fut.get()`.

# Introduction
`std::async` behaves similar to an asynchronous function call. This function call takes a _**callable**_ together with its arguments. `std::async` is a variadic template and can, therefore, take an arbitrary number of arguments. The call to `std::async` returns a future object `fut`. That's your handle for getting the result via `fut.get()`.

>🔑 **std::async should be your first choice**
>
>The C++ runtime decides if `std::async` is executed in a separate thread. The decision of the C++ runtime may depend on the available number of CPU cores, the utilization of your system, or the size of your work package. By using `std::async`, you only specify the task that will run. The C++ runtime automatically manages the creation and the lifetime of the thread. 


## Eager or Lazy Evaluation
Optionally, you can specify a launch policy for `std::async`.

With the launch policy, you can explicitly specify whether the asynchronous call should be executed in the same thread (`std::launch::deferred`) or in another thread (`std::launch::async`).
 

> **Eager versus lazy evaluation**
>
> Eager and lazy evaluations are two orthogonal strategies to calculate the result of an expression. In the case of [eager evaluation](https://en.wikipedia.org/wiki/Eager_evaluation), the expression will be evaluated immediately - in the case of [lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation), the expression will only be evaluated if needed. Eager evaluation is often called **greedy evaluation**, and lazy evaluation is often called **call-by-need**. With lazy evaluation, you save time and compute power as there is no evaluation on suspicion. 

By default, the launch policy of `std::async` is `std::launch::async` | `std::launch::deferred`, meaning that the system determines if it will execute the work package eagerly or lazily.

What is special about the call `auto fut= std::async(std::launch::deferred, ... )` is that the promise will not be executed immediately. The call `fut.get()` starts the promise lazily, meaning that the promise will only run if the future asks for the result via `fut.get()`.

# Introduction
`std::async` behaves similar to an asynchronous function call. This function call takes a _**callable**_ together with its arguments. `std::async` is a variadic template and can, therefore, take an arbitrary number of arguments. The call to `std::async` returns a future object `fut`. That's your handle for getting the result via `fut.get()`.

>🔑 **std::async should be your first choice**
>
>The C++ runtime decides if `std::async` is executed in a separate thread. The decision of the C++ runtime may depend on the available number of CPU cores, the utilization of your system, or the size of your work package. By using `std::async`, you only specify the task that will run. The C++ runtime automatically manages the creation and the lifetime of the thread. 


## Eager or Lazy Evaluation
Optionally, you can specify a launch policy for `std::async`.

With the launch policy, you can explicitly specify whether the asynchronous call should be executed in the same thread (`std::launch::deferred`) or in another thread (`std::launch::async`).
 

> **Eager versus lazy evaluation**
>
> Eager and lazy evaluations are two orthogonal strategies to calculate the result of an expression. In the case of [eager evaluation](https://en.wikipedia.org/wiki/Eager_evaluation), the expression will be evaluated immediately - in the case of [lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation), the expression will only be evaluated if needed. Eager evaluation is often called **greedy evaluation**, and lazy evaluation is often called **call-by-need**. With lazy evaluation, you save time and compute power as there is no evaluation on suspicion. 

By default, the launch policy of `std::async` is `std::launch::async` | `std::launch::deferred`, meaning that the system determines if it will execute the work package eagerly or lazily.

What is special about the call `auto fut= std::async(std::launch::deferred, ... )` is that the promise will not be executed immediately. The call `fut.get()` starts the promise lazily, meaning that the promise will only run if the future asks for the result via `fut.get()`.

This lesson offers an introduction to std::async, which is used in C++ for multithreading.

Introduction

Safety-Critical Systems

High Performance

Reduced Resources

Several Tasks Simultaneously

Conclusion

std::async

Introduction