add various notes, change some wording by robamu · Pull Request #402 · ferrous-systems/rust-training

robamu · 2026-07-22T14:28:52Z

No description provided.

cloudflare-workers-and-pages · 2026-07-22T14:30:02Z

Deploying ferrous-systems-rust-training with Cloudflare Pages

Latest commit:	`be16011`
Status:	✅ Deploy successful!
Preview URL:	https://74a41923.ferrous-systems-rust-training.pages.dev
Branch Preview URL:	https://more-async-slide-improvement.ferrous-systems-rust-training.pages.dev

View logs

robamu · 2026-07-27T10:01:56Z

+
+- Imperative: Statements in synchronous code are just executed step-by-step.
+
+## Async language support


this is a new slide. I think the auto-generation of state machines is a fact worth mentioning?
In embedded, we commonly replace annoying state machines using async, which is really nice.

robamu · 2026-07-27T10:02:28Z

 * sync programming often has imperative behaviour
-* async programming is about constructing a process at runtime and then executing it
-* this process is called the "futures tree"
+* async programming is about constructing an execution plan and then letting an executor run it


is "execution plan" something that makes sense here?

not really; the executor doesn't know ahead of time what's going to be run, and the async task can spawn more tasks at runtime. see https://jyn.dev/what-is-a-build-system-anyway/#applicative-and-monadic-structure for more discussion.

robamu · 2026-08-21T08:02:11Z

 ## Async

-* Built from important "building blocks"
+* Built from important building blocks, which are partially baked into the language


wondering why "building blocks" was in quotes, was there a specific reason? I also mentioned that the async/await is partially baked into the language. is this superfluous?

robamu · 2026-08-21T08:02:46Z

 * sync programming often has imperative behaviour
-* async programming is about constructing a process at runtime and then executing it
-* this process is called the "futures tree"
+* async programming is an abstraction that allows developers to define pausing points where


Paraphrased from https://doc.rust-lang.org/book/ch17-00-async-await.html. I think this is an excellent simplification for explaining the difference between sync / async.

i would phrase this as "waiting points" to closer parallel the await syntax, or "yield points" to parallel your wording below.

robamu · 2026-08-21T08:23:09Z

+Note:
+
+- function must be `async` so `await` can be used inside it.
+- The code between two `await`ion points has a regular synchronous flow.


I think this might be worth mentioning? at awaition points, the executor might pause and do some other pending work, but the flow between the awaition points is still regular synchronous code.

yes, this is very worth mentioning. you might be interested in https://ryhl.io/blog/async-what-is-blocking/, particularly the bit that says "other tasks on the same runtime will stop running until the thread is no longer being blocked".

jyn514

I can't comment on why the existing wording is there, but I've done a pass confirming factual changes. This looks good overall :) just small wording suggestions.

jyn514 · 2026-08-21T09:50:43Z

 * sync programming often has imperative behaviour
-* async programming is about constructing a process at runtime and then executing it
-* this process is called the "futures tree"
+* async programming is an abstraction that allows developers to define pausing points where


i would phrase this as "waiting points" to closer parallel the await syntax, or "yield points" to parallel your wording below.

jyn514 · 2026-08-21T09:51:39Z

+
+Note:
+
+- Imperative: Statements in synchronous code are just executed step-by-step.


Suggested change

- Imperative: Statements in synchronous code are just executed step-by-step.

- Imperative: Statements in single-threaded synchronous code are always executed in order. Statements in asynchronous code may be executed out-of-order, even in a single thread.

what is the "out-of-order" related to here? because some processors can re-order or perform "out-of-order" execution on synchronous code as well, right?

jyn514 · 2026-08-21T09:52:24Z

+## Async language support
+
+* `async` functions can define yield points where the execution can be paused, represented by
+  `await`ion points.


Suggested change

`await`ion points.

`.await` syntax.

jyn514 · 2026-08-21T09:53:41Z

+Note:
+
+- function must be `async` so `await` can be used inside it.
+- The code between two `await`ion points has a regular synchronous flow.


yes, this is very worth mentioning. you might be interested in https://ryhl.io/blog/async-what-is-blocking/, particularly the bit that says "other tasks on the same runtime will stop running until the thread is no longer being blocked".

jyn514 · 2026-08-21T09:53:53Z


+Note:
+
+- Helpful mental model: A `async` function is a regular synchronous functions that returns a `Future`.


💯. effectively async fn is a promise to the reader "no synchronous work happens before i return a Future".

jyn514 · 2026-08-21T09:55:36Z


+Note:
+
+- Alternative wording: A future can be resolved or polled to completion.


"resolved or polled to completion" makes it sound like these are two different things, but they're the same. i would say "futures can be resolved by polling them to completion, or canceled by dropping them".

jyn514 · 2026-08-21T09:57:01Z

+- On full operating systems, mechanisms like `epoll` are used
+- On embedded systems, interrupts are used to advance or complete operations


this mingles implementation details with your runtime environment. you can have a hosted system that uses Unix signals for progress, and you can have an embedded system that uses spin-loops to poll without needing interrupts.

maybe still useful to keep them as examples?

👍 examples seem good, as long as you make it clear that hosted/embedded is independent of polling/event-wakers

Okay, I updated this again. Considering that most use-cases will use an event driven mechanism, what do you think about the current version?

jyn514 · 2026-08-21T15:11:49Z

+- On full operating systems, OS mechanisms like `epoll`.
+- On embedded systems, interrupts to advance or complete operations.


this still confuses polling/event-driven with hosted/embedded. i would prefer to state the two axes separately.

robamu marked this pull request as ready for review July 27, 2026 10:00

robamu commented Jul 27, 2026

View reviewed changes

robamu requested review from Copilot, listochkin and skade and removed request for Copilot July 27, 2026 10:03

Copilot started reviewing on behalf of robamu July 27, 2026 10:03 View session

robamu commented Aug 21, 2026

View reviewed changes

robamu force-pushed the more-async-slide-improvements branch from dcb9e74 to 4f98604 Compare August 21, 2026 08:17

add various notes, change some wording

44eaaa2

robamu force-pushed the more-async-slide-improvements branch from 99f0752 to 44eaaa2 Compare August 21, 2026 08:21

robamu commented Aug 21, 2026

View reviewed changes

jyn514 reviewed Aug 21, 2026

View reviewed changes

code review suggestions

11bd373

robamu requested a review from jyn514 August 21, 2026 14:37

jyn514 reviewed Aug 21, 2026

View reviewed changes

robamu added 2 commits August 24, 2026 10:27

make distinction between polling/even based mechanisms more clear

9bfa1bd

maybe this is better

be16011

robamu requested a review from jyn514 August 24, 2026 08:51

listochkin approved these changes Aug 24, 2026

View reviewed changes


		- Imperative: Statements in synchronous code are just executed step-by-step.

		## Async language support


		Note:

		- Imperative: Statements in synchronous code are just executed step-by-step.

	- Imperative: Statements in synchronous code are just executed step-by-step.
	- Imperative: Statements in single-threaded synchronous code are always executed in order. Statements in asynchronous code may be executed out-of-order, even in a single thread.


		Note:

		- Helpful mental model: A `async` function is a regular synchronous functions that returns a `Future`.


		Note:

		- Alternative wording: A future can be resolved or polled to completion.

		- On full operating systems, mechanisms like `epoll` are used
		- On embedded systems, interrupts are used to advance or complete operations

		- On full operating systems, OS mechanisms like `epoll`.
		- On embedded systems, interrupts to advance or complete operations.

Uh oh!

Conversation

robamu commented Jul 22, 2026

Uh oh!

cloudflare-workers-and-pages Bot commented Jul 22, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Deploying ferrous-systems-rust-training with Cloudflare Pages

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jyn514 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

cloudflare-workers-and-pages Bot commented Jul 22, 2026 •

edited

Loading