Michael-F-Bryan

Obsidian Tricks: Daily Notes

Mon, 28 Jul 2025 12:00:00 +0800

If you’re new to Personal Knowledge Management, let me share something that took me years to fully appreciate: daily notes are the secret sauce that transforms a collection of random notes into a living, breathing knowledge system.

Here’s the thing most people miss when they start with PKM—it’s not about having perfect notes, it’s about connecting your notes to real moments in time. Daily notes do exactly that. They’re like having a personal assistant who remembers not just what happened, but when it happened and who was involved.

Obsidian Tricks: Entity Notes

Wed, 23 Jul 2025 12:00:00 +0800

An entity is a person, place, or organization that you want to track in your Second Brain. By creating separate notes in your Obsidian vault for each entity and using the power of backlinks, you can create a rich, interconnected knowledge base.

The Power of Backlinks Link to heading

When you create a dedicated note for an entity like [[Michael Bryan]] or [[Wasmer]], every time you mention that entity in any other note, Obsidian automatically creates a backlink. This creates a dynamic, interconnected web of knowledge that reveals patterns and connections you might not have noticed otherwise.

Obsidian Tricks: The Summary Callout

Sat, 19 Jul 2025 22:36:07 +0800

The [!summary] callout is a crucial component of an Atomic Note, serving as a concise overview that captures the essence of the note’s content. This section at the beginning of each note helps readers quickly grasp the main concept and decide whether to read further.

Feel free to use this article as a prompt to generate your own summary callout 😉

Purpose and Structure Link to heading

Quick Overview: Provides readers with essential information without requiring them to read the entire note
Placement: Always at the top of the note, after Front Matter (if present)
Format: Uses the blockquote syntax with callout type: > [!summary] (variations like [!SUMMARY] or [!Summary] are acceptable)
Length: Typically 1-3 sentences or 3-5 bullet points for complex topics

Content Guidelines Link to heading

Focus:
- Capture the core idea without including supporting details
- Answer “What is it?” and “Why is it important?”
- Include key relationships to other concepts when relevant
Style:
- Clear, direct, and professional tone
- Active voice and present tense
- Avoid jargon unless essential to the concept
Links:
- Include essential [[wiki-links]] to related core concepts
- Don’t overload with links - only the most relevant ones
Formatting:
- Use emphasis (italics or bold) for critical terms
- Include code snippets in backticks for technical terms
- Break complex summaries into bullet points for readability

Context-Specific Patterns Link to heading

Technical Concepts Link to heading

---
aliases: Access Tokens
---

> [!SUMMARY]
> A token, typically in the [[JSON Web Tokens|JWT]] format, issued by a server
> when the user logs in that lets users make secure calls to an API server.

User tokens can be used by client applications to access protected resources on
a server on behalf of a user.

Anyone that holds an access token can use it. As such, you need a way to
minimize the fallout from a compromised access token. One method is to issue
tokens that have a short lifespan.

Here is an example access token that might be issued by [[Auth0]]:

```json
{
  "iss": "https://YOUR_DOMAIN/",
  "sub": "auth0|123456",
  "aud": [
    "my-api-identifier",
    "https://YOUR_DOMAIN/userinfo"
  ],
  "azp": "YOUR_CLIENT_ID",
  "exp": 1489179954,
  "iat": 1489143954,
  "scope": "openid profile email address phone read:appointments"
}
```

Entities Link to heading

From my note on Anduril Industries:

Writing Technical Content That Actually Helps People

Wed, 16 Jul 2025 10:00:00 +0800

I’ve been writing technical content for years, and I’ll be honest - I never really thought about how I was writing it. I just wrote the way I think and communicate naturally. Kind of like a stream-of-consciousness documentary of my problem-solving process.

Then I started getting feedback that surprised me. People would say things like “Your explanations actually make sense” or “I finally understand this concept after reading your article.” At first, I figured they were just being nice. But it kept happening.

How I Work

Mon, 14 Jul 2025 12:00:00 +0800

I thought it might be helpful to write down some of the core principles and values that guide my professional life. If you are a colleague, friend, potential employer, or just curious, this might be a good place to start.

Give me ownership, trust my judgement, keep communication open, and let me focus on building things properly.

In return, you’ll get high-quality work, honest feedback, and a teammate who’ll go the extra mile when it matters.

Link Time Dependency Injection

Sun, 30 Mar 2025 12:59:58 +0800

Have you ever been in a situation where, because of how the code is structured, it’s practically impossible to inject a dependency into the component that needs it? Even global variables - ubiquitously reviled for their ability to do “spooky action at a distance” - weren’t spooky enough.

In this article, I’ll share a technique I discovered while working on a WebAssembly-based CAD package that allows for dependency injection at link time. This technique is particularly useful when traditional dependency injection methods aren’t available or practical.

Reboot Friendly Projects - Building Systems That Let You Disappear (and Come Back)

Sat, 29 Mar 2025 12:59:58 +0800

You get an idea. You get excited. You start building.

Then one day — you stop.

No dramatic reason. No catastrophic failure. Just… gone. You forget about it. Or you can’t bear to look at it. Or you move on. And when you do want to come back, you can’t remember what anything meant or why you even cared.

This isn’t a lack of discipline. It’s just a natural part of working on long-term or creative projects.

Embracing a New Chapter: My Farewell to Wasmer and the Journey Ahead

Tue, 30 Jan 2024 17:00:00 +0800

Introduction Link to heading

My journey at Wasmer has been a profound chapter in my life, filled with both incredible achievements and challenging moments. It’s time for me to share an important decision about my career and the path I’m choosing to embark on.

The Journey at Wasmer Link to heading

Wasmer, though a small company, has enabled us to achieve some pretty impressive feats together.

GitHub Actions can't access private repos? Here's how to fix it

Tue, 13 Sep 2022 12:01:45 +0800

When developing locally, you can add a private GitHub repository to your Rust crate as a git dependency and cargo should be able to retrieve it just fine.

However, when you push your changes to GitHub and run CI, GitHub Actions can run into authentication issues when trying to build your crate.

This is the error message I was fighting for a good part of today:

$ cargo check --workspace --verbose --locked
 Updating git repository `https://github.com/Michael-F-Bryan/my-secret-repo.git`
 Running `git fetch --force --update-head-ok 'https://github.com/Michael-F-Bryan/my-secret-repo.git' '+HEAD:refs/remotes/origin/HEAD'`
Error: failed to get `internal-crate` as a dependency of package `some-crate v0.1.4 (/home/runner/work/some-crate/some-crate/crates/cli)`
Caused by:
 failed to load source for dependency `internal-crate`

Caused by:
 Unable to update https://github.com/Michael-F-Bryan/my-secret-repo.git

Caused by:
 failed to clone into: /home/runner/.cargo/git/db/my-secret-repo-20c1af0756e23bf7

Caused by:
 process didn't exit successfully: `git fetch --force --update-head-ok 'https://github.com/Michael-F-Bryan/my-secret-repo.git' '+HEAD:refs/remotes/origin/HEAD'` (exit status: 128)
 --- stderr
 fatal: could not read Username for 'https://github.com': No such device or address
Error: The process '/home/runner/.cargo/bin/cargo' failed with exit code 101

Cargo can’t check out my private repository!

Announcing Cargo WAPM

Sun, 07 Aug 2022 16:14:07 +0800

While at Hammer of the Gods, we wrote a lot of Rust code that gets compiled to WebAssembly for use in our containerization technology, Rune.

We have over 30 different processing blocks (chunks of code that can be used in a data processing pipeline) and as you can imagine, publishing and versioning each of WebAssembly module manually isn’t practical. For that, we lean on the WebAssembly Package Manager to do all the heavy lifting.

Bringing include_dir Into the Modern Era

Thu, 06 Jan 2022 09:57:09 +0800

Way back in mid-2017 I created a crate called include_dir with a single goal in mind - give users an include_dir!() macro that lets them embed an entire directory in their binary.

By most metrics, we’ve been doing phenomenally well. The crate has received a fair amount of engagement on GitHub via pull requests and issues, and it has had over 1 million downloads and 127 direct dependents published to crates.io alone.

Common Newbie Mistakes and Bad Practices in Rust: Bad Habits

Mon, 27 Sep 2021 18:30:00 +0800

When you are coming to Rust from another language you bring all your previous experiences with you.

Often this is awesome because it means you aren’t learning programming from scratch! However, you can also bring along bad habits which can lead you down the wrong rabbit hole or make you write bad code.

The code written in this article is available on the Rust Playground using the various (playground) links dotted throughout. Feel free to browse through and steal code or inspiration.

Daily Rust: Iterators

Tue, 24 Aug 2021 03:55:00 +0800

Iterators are part of Rust’s secret sauce. They power things from the humble for-loop to the elegant iterator chain, but have you ever stopped to think how they work?

Let’s find out more about Rust’s iterators by implementing our own versions of common iterators and reading the standard library’s source code.

The code written in this article is available on the Rust Playground using the various (playground) links dotted throughout. Feel free to browse through and steal code or inspiration.

Daily Rust: Slice Patterns

Sat, 14 Aug 2021 00:00:00 +0000

Rust 1.26 introduced a nifty little feature called Basic Slice Patterns which lets you pattern match on slices with a known length. Later on in Rust 1.42, this was extended to allow using .. to match on “everything else”.

As features go this may seem like a small addition, but it gives developers an opportunity to write much more expressive code.

The code written in this article is available in the various playground links dotted throughout. Feel free to browse through and steal code or inspiration.

Deserializing Binary Data Files in Rust

Sun, 20 Jun 2021 00:30:00 +0800

The other day, someone on the Rust user forums posted a question that really nerd-sniped me. They had data generated by a C++ program and were wanting to load it into a Rust program, but when asked what format the data was in the author didn’t provide some something like a JSON schema or Protobuf file, instead they just got the definition for a C struct.

A common method for “serializing” data in C is to create a struct and directly write its bytes into a file, the “deserializing” is just a case of reading the data out of the file and interpreting it as your type. This technique is actually kinda genius when you think about it, it makes no intermediate copies or heap allocations because the OS’s read() function will literally write your data to its destination, and there are no extra dependencies or complicated serialization frameworks involved.

Parsing PDF Documents in Rust

Sun, 31 Jan 2021 21:00:00 +0800

In my spare time I’m a volunteer with my state’s emergency services and we have our own web app for managing unit-specific things like attendance, vehicle checks, newsletters, on-call rosters, and so on.

It’s actually a really useful tool, but there is one feature that really annoys me… The list of member contact details is only available as a PDF and not a format that can be imported into your phone’s contacts.

FFI-Safe Polymorphism: Thin Trait Objects

Wed, 16 Dec 2020 02:00:00 +0800

A while ago someone posted a question on the Rust User Forums asking how to achieve polymorphism in a C API and while lots of good suggestions were made, I’d like to explore my take on things.

As a recap, Rust provides two mechanisms for letting you write code which will work with multiple types. These are

Static Dispatch, where the compiler will generate multiple copies of the function, tailor-made for each type and resolved at compile time, and
Dynamic Dispatch, where we use an extra level of indirection to only resolve the actual implementation at runtime

While both mechanisms are extremely powerful and can cover almost all of your needs in normal Rust code, they both have one drawback… The actual mechanisms used are (deliberately) unspecified and not safe for FFI.

How I Translate Feature Requests into Code

Wed, 02 Dec 2020 16:10:00 +0800

As part of my previous job I worked on a CAD/CAM package, and a very common task would be to take a vague feature description, rephrase it as a more formal software problem, then use computational geometry algorithms to turn it into code which can be integrated into the overall application.

I eventually got quite good at this, so I’m going to write down the system I came up with. This process works especially well for larger features which add new functionality with minimal coupling to existing code.

Geometric Constraint Solvers Part 1: Algebraic Expressions

Wed, 15 Jul 2020 00:40:00 +0800

A really powerful tool in Computer Aided Design (CAD) is the ability to apply “constraints” to your drawing. Constraints are a really powerful tool, allowing the drafter to declare how parts of their drawing are related, then letting the CAD program figure out how parameters can be manipulated in such a way that

You can think of a constraint as some sort of mathematical relationship between two or more parameters.

Writing Non-Trivial Macros in Rust

Sun, 21 Jun 2020 01:15:00 +0800

Macros in Rust tend to have a reputation for being complex and magical, the likes which only seasoned wizards like @dtolnay can hope to understand, let alone master.

Rust’s declarative macros provide a mechanism for pattern matching on arbitrary syntax to generate valid Rust code at compile time. I use them all the time for simple search/replace style operations like generating tests that have a lot of boilerplate, or straightforward trait implementations for a large number of types.

Rust Closures in FFI

Tue, 12 May 2020 22:00:00 +0800

Every now and then when using native libraries from Rust you’ll be asked to pass a callback across the FFI boundary. The reasons are varied, but often this might be done to notify the caller when “interesting” things happen, for injecting logic (see the Strategy Pattern), or to handle the result of an asynchronous operation.

If this were normal Rust, we’d just accept a closure (e.g. a Box<dyn Fn(...)> or by being generic over any function-like type) and be done with it. However, when working with other languages you are reduced to the lowest common denominator, a the C language (or more specifically, the ABI and machine code in general) doesn’t understand generics or Rust’s “fat” pointers.

Creating a Robust, Reusable Link-Checker

Sat, 02 May 2020 19:20:00 +0800

With over 68,842 downloads, one of my most successful Rust projects is a nondescript little program called mdbook-linkcheck. This is a link-checker for mdbook, the tool powering a lot of documentation in the Rust community, including The Rust Programming Language and The Rustc Dev Book.

As an example of what it looks like, I recently found a couple broken links in the documentation for Chalk. When the tool detects broken links in your markdown it’ll emit error messages that point you at the place the link is defined and explain what the issue is.

How I Reverse Engineered the LastPass CLI Tool

Tue, 14 Apr 2020 22:40:00 +0800

A couple days ago I was writing an install script for my dotfiles and reached a point where I wanted to grab some secrets (my SSH keys) from my LastPass vault and copy them to the file system.

This is easy enough to do using the browser plugin, or even when working with their command line tool (lpass) in an interactive way, but I found there was no way to ask lpass which files are attached to a secret, and get the output in a machine readable format.

Reflections on What Motivates a Person

Sun, 05 Apr 2020 19:15:00 +0800

Motivation is a funny thing.

I’m someone who’s productivity levels change wildly depending on my motivation levels. When I work on something which I’m passionate about or which interests me on an intellectual level (e.g. computational geometry or systems programming), I’m routinely 5-10x more productive than my peers.

However, if I’m working on something which is less personally interesting (e.g. tracking down GUI bugs or creating yet another CRUD app) I’ll tend to drag my feet and not work as hard.

Line Simplification with Ramer–Douglas–Peucker

Sun, 23 Feb 2020 21:56:00 +0800

The other day I needed to do a fairly routine graphical operation, to “simplify” a polyline with many points into a simpler polyline which has roughly the same shape plus or minus some tolerance factor.

My actual use case was in sending linear movements to a CNC machine. Drawings are defined using floating point numbers and can be “accurate” to about 7-15 decimal places (depending on if you use floats or doubles) but when you take the machine’s mechanical tolerances and material effects into account the final cut is only really accurate to about 1 decimal place (0.1 mm). If I were to simplify the path with a tolerance of, say, 0.05 mm I could massively reduce the number of points sent to the machine (which reduces the amount of data sent, buffer sizes, communications overhead, etc.) with minimal effect on the accuracy.

A Pragmatic Approach To Global State

Mon, 17 Feb 2020 22:22:47 +0800

One of the first things I learned when programming professionally is that global variables are bad. We all take it for granted that it’s bad practice to write code that relies heavily on global state but the other day I was working with a 3rd party native library, and it reminded why these best practices come about.

There are a couple factors which made this particular library’s use of global mutable state rather ugly to work with,

I Made A Thing: Markedit

Sun, 09 Feb 2020 04:40:00 +0800

A couple days ago I released markedit, a small crate for editing unstructured markdown documents. This is a useful enough library that I thought I’d explain the main ideas behind it and potential use cases.

This originally came about when I was at work, preparing our application’s change log before a release for the umpteenth time (we’ve found the keep a changelog format really useful) and on the drive home I started thinking of ways to automate things.

Creating Interactive Applications While Maintaining Your Sanity

Thu, 06 Feb 2020 23:43:00 +0800

One of the primary reasons computers are so ubiquitous in modern society is their ability to let humans and software cooperate to achieve a desired goal. That is, to be interactive.

Creating interactive applications can be pretty annoying for a programmer. Unlike a computer which is predictable and will blindly follow any instructions given to it,

Humans are unpredictable. They like to press buttons and push features further than they were originally intended
Humans have a habit of asking for special cases (“Feature X works really well, but when I click on this triangle while holding shift and tilting my head at an angle, it should really do Y instead. It’s not a big feature, can you just add?”)
Humans often don’t know what they want, meaning even if you implement something exactly as described to you users will still complain about it not doing the right thing
The real world is messy, and letting users interact with your program is a really effective way of mixing the messy outside world with the nice structured world inside a computer
Also, users are the ones funding your pay check so you should probably try to keep them happy 😁

The ideas and concepts shown in this article aren’t overly advanced. In fact, if you’ve been programming for a couple months (especially if it’s part of a formal Computer Science program) you’re probably already familiar with them.

Words Are Hard - An Essay on Communicating With Non-Programmers

Mon, 27 Jan 2020 10:20:00 +0800

There’s a well-known saying about the hard problems in computer science, of which I think this is my favourite variant,

There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors.
— Leon Bambrick (@secretGeek) January 1, 2010

I’ve been writing software long enough to be burned by all three at some point, but as someone working in a small business who represents the software side of our product and is constantly rubbing shoulders with non-programmers, I believe the ability to correctly communicate an idea or concept in a way that others can understand (i.e. to name things) is by far the most important.

A Thought Experiment: Using the ECS Pattern Outside of Game Engines

Sat, 28 Dec 2019 00:00:00 +0800

It’s been about 6 months since I watched Catherine West’s excellent Using Rust for Game Development sent me down the Entity-Component-System (ECS) rabbit hole, and I thought I’d share some of my findings.

I’ve been meaning to write about this for quite a while now but it took a while to put my thoughts into a cohesive article without throwing massive walls of code at you.

This article is mainly focused around the high-level decisions you make when designing a project, so there won’t be as much code as normal. That said, all code written in this article is available on GitHub. Feel free to browse through and steal code or inspiration.

WebAssembly as a Platform for Abstraction

Sun, 15 Dec 2019 11:55:00 +0800

In a project I’ve been playing around with recently, we’ve encountered the dilemma where you want to make it easy for users to write their own application logic using the system but at the same time want to keep that logic decoupled from the implementation details of whatever platform the application is running on.

If you’ve been programming for any amount of time your immediate reaction is probably “why bother mentioning this, doesn’t it just fall out of good library design?”, and normally I would totally agree with you, except I forgot to mention a couple of important details…

How to RiiR

Mon, 02 Dec 2019 01:00:00 +0800

In a previous article we’ve talked about how you can avoid rewriting a library in Rust when you don’t need to. But what about the times when you really do need to?

In most languages you’d need to rewrite the entire library from the ground up, waiting until the port is almost finished before you can start seeing results. These sorts of ports tend to be quite expensive and error-prone, and often they’ll fail midway and you’ll have nothing to show for your effort. Joel Spolsky does a much better job of explaining this than I ever could, see his article on why full rewrites are a bad idea for more.

Implementing ArrayVec Using Const Generics

Fri, 15 Nov 2019 00:57:00 +0800

If you’ve ever done much embedded programming in Rust, you’ve most probably run across the arrayvec crate before. It’s awesome. The main purpose of the crate is to provide the ArrayVec type, which is essentially like Vec<T> from the standard library, but backed by an array instead of some memory on the heap.

One of the problems I ran into while writing the Motion Planning chapter of my Adventures in Motion Control was deciding how far ahead my motion planner should plan.

Audio Processing for Dummies

Sun, 27 Oct 2019 23:34:00 +0800

In my spare time I’m an emergency services volunteer, and one of the tasks our unit has is to run the radio network and keep track of what’s happening. This can be a pretty stressful job, especially when there’s lots of radio traffic, and it’s not unusual to miss words or entire transmissions.

To help with a personal project that could make the job easier I’d like to implement a basic component of audio processing, the Noise Gate.

How to not RiiR

Sun, 20 Oct 2019 19:45:00 +0800

Once you get past the growing pains of the Borrow Checker and realise Rust gives you the power to do things which would be unheard of (or just plain dangerous) in other languages, the temptation to Rewrite it in Rust can be quite strong. However at best, the temptation to RiiR is unproductive (unnecessary duplication of effort), and at worst it can promote the creation of buggy software (why would you be better equipped to write a library for some domain-specific purpose than the original author?).

Working With G-Code

Fri, 18 Oct 2019 00:05:00 +0800

As mentioned in the previous post there are a handful of tasks which may be tackled next, but only one of them really allows us to make progress towards our goal of implementing the simulated firmware for a 3D Printer.

Let’s send the motion controller some g-code.

Creating Message types Link to heading

If we want to send g-code programs between the frontend and backend we’ll need to make a couple message definitions.

Wiring Up Communication

Thu, 10 Oct 2019 22:58:00 +0800

As we mentioned in the last AiMC post, the next task is to wire up communications between the simulator’s backend and frontend.

As a general rule, our frontend will have two communication regimes:

When something happens (e.g. a button is pressed or a job starts sending), the frontend will send a batch of messages to the backend and interpret the response
The frontend will continually poll the backend’s state in the background (e.g. at 10Hz)

As it is, the Browser in our WASM code already provides a method for sending data to the frontend (Browser::send_data()) and receiving data from the frontend (App::on_data_received()) so we shouldn’t need to write any Rust code.

Plugins in Rust

Mon, 30 Sep 2019 22:04:58 +0800

Imagine you are implementing a calculator application and want users to be able to extend the application with their own functionality. For example, imagine a user wants to provide a random() function that generates true random numbers using random.org instead of the pseudo-random numbers that a crate like rand would provide.

The Rust language gives you a lot of really powerful tools for adding flexibility and extensibility to your applications (e.g. traits, enums, macros), but all of these happen at compile time. Unfortunately, to get the flexibility that we’re looking we’ll need to be able to add new functionality at runtime.

A Better Frontend

Fri, 27 Sep 2019 03:47:00 +0800

Now we’ve got a half-usable motion controller, we need a graphical way for humans to interact with it. The controller runs in a browser, which makes Vue a perfect candidate for the UI.

Adding Vue to the Frontend Link to heading

Now, we don’t actually have much frontend code (47 lines of JavaScript to be exact) so it’s actually easier to delete the existing frontend and use the vue CLI tool to create a new one.

Initial Motion System

Wed, 18 Sep 2019 20:00:00 +0800

Now we’ve got some simple automation code, lets start a proper Motion system.

Most Motion systems are designed around a “control mode”, a fancy term for “what is the machine doing right now?” Common control modes are:

Idle - the default control mode, machines revert to Idle whenever they’re not doing anything
Automation - running an automation sequence
Recipe - executing a job (a set of instructions for how to execute a job and the motion parameters that should be used is often referred to as a Recipe)
Manual - manual movement, where velocity may be controlled via a handset or the user invokes a “jog to position” function

There are several ways to transition between control modes.

Simple Automation Sequences

Sat, 14 Sep 2019 23:55:00 +0800

Now we can communicate with the outside world, let’s start interacting with the “hardware” attached to our motion controller. This will be the beginning of our Motion system.

The simplest way to interact with the world is by executing a pre-defined routine, and one of the simplest useful routines is to move all axes to the home position.

System Inputs and Outputs Link to heading

From our initial requirements gathering we know that our 3D printer will have three linear axes (X, Y, and Z), with limit switches at the ends of each axis. This gives our new Motion system six inputs to deal with.

The Communications System: Part 2

Sun, 08 Sep 2019 01:20:00 +0800

Now we have a mechanism for transferring bytes from the frontend to the simulator and back again, we need to translate those bytes into higher-level messages. Luckily each [anpp::Packet] contains an ID field that is designed specifically for this purpose.

That lets us do something like this:

// (not real code)

enum Message<'a> {
    Ping,
    StatusCheck,
    ProgramChunk {
        chunk_number: usize,
        body: &'a [u8],
    },
    ...
}

struct UnknownMessageError;

fn parse_packet<'a>(pkt: &'a Packet) -> Result<Message<'a>, UnknownMessageError> {
    match pkt.id() {
        0 => Ok(Message::Ping),
        1 => Ok(Message::StatusCheck),
        2 => Ok(...),
        _ => Err(UnknownMessageError),
    }
}

The top-level App can handle messages by routing them to the appropriate system and invoking a message handler.

The Communications System: Part 1

Fri, 06 Sep 2019 23:00:00 +0800

Prelude Link to heading

The Communications system is arguably one of the most important parts of our simulator. After all, it’s kinda hard to debug a program when you can’t ask it why something isn’t working.

The user will interact with our simulated motion controller via a single Serial Port, which we’ll be modelling as a simple thing which sends and receives bytes. Serial ports are a fairly old technology, and have several drawbacks compared to the Ethernet and TCP protocols that most programmers are familiar with.

FPS Counter

Tue, 03 Sep 2019 08:50:00 +0800

As mentioned in the previous article the next task is to implement our first proper System, the FpsCounter.

A relatively easy, yet important, component is some sort of FPS counter. Ideally there’ll be a bit of text in the corner showing the number of poll()s per second and the average duration. That way we can get a better feel for our simulator’s performance characteristics.

An FpsCounter has two responsibilities,

Top-Level Infrastructure

Mon, 02 Sep 2019 21:22:30 +0800

As mentioned in the intro article, the first task will be to set up the application’s structure and define how the various components will communicate.

Multitasking Link to heading

Most embedded systems will implement multi-tasking by rapidly polling each system within an infinite loop.

loop {
    poll_comms();
    poll_motion_planning();
    poll_io();
    poll_machine_events();
}

A motion controller will normally spend most of its time polling, but there are places where polling isn’t appropriate. For example, accurate movement of a stepper motor relies on sending pulses at very precise times. Another scenario is in the handling of communication, where waiting for the next poll to read a byte may result in missing part of a message.

Announcing Adventures in Motion Control

Sun, 01 Sep 2019 16:27:15 +0800

This is the first installation in my Adventures in Motion Control series.

At $JOB we build industrial CNC machines, and while developing a simulator for our machines I noticed a distinct lack of online resources on how they work under the hood. Hopefully this series will address the situation.

The Goal Link to heading

The goal for this series is to develop a simulator which will accurately reflect how an embedded motion controller is implemented internally.

About Me

Mon, 01 Jan 0001 00:00:00 +0000

I’m Michael Bryan, a software engineer based in Perth, WA, with a passion for building resilient systems and elegant solutions.

Professional Overview Link to heading

I’m currently a Senior Software Engineer at Multiversal Ventures, primarily focused on developing robust web crawlers at scale and leveraging ML to extract information from US healthcare websites.

I specialise in writing precise, maintainable code and consider myself an expert in Rust, with extensive experience in Go, TypeScript, React, and GraphQL. I’m particularly passionate about compilers, type-safe code, and designing parsers that gracefully handle errors.