DEV Community: Weekly Typed

Embedded Rust on ESP32

Weekly Typed — Mon, 04 Sep 2023 17:39:39 +0000

A while back, I bought a STM32F3 Discovery board, fully intending to use it to complete the Discovery Book. Unfortunately, it took a long time to ship, and most of the novelty had worn off by the time I got started. I barely completed the introductory, blinking LED project, and the Discovery board has been sitting in a drawer ever since.

These interests of mine tend to be cyclical, though, and embedded development finally came back up recently. I was seeing some interesting projects on YouTube channels like Volos Projects, that introduced me to ESP32 and the associated line of development boards. It turns out ESP32 boards have some neat features, like wifi and bluetooth. They are also super popular. So when, I noticed regular updates to esp-hal showing up in This Week in Rust, I got a little excited.

As it happens, Espressif (the company that makes ESP32) and the Rust on ESP Community have been going pretty hard to make Rust on ESP easy.

Here's a bit about what I've learned.

A proper hosted environment

Look, programming on bare metal sounds cool. It sounds super hackery. But I don't want to dive into that right off the bat. I do want some guardrails so I don't lose my way. But, at the same time, I'm not really drawn to dev boards like Arduino and Raspberry Pi. The vibe I get from them is a high level of abstraction.

ESP32 development has great Rust support, and the level of abstraction is right where I want it. The Espressif Integrated Development Framework (ESP-IDF) provides a base layer of components that makes it a lot easier to build applications, including a "newlib" that enables use of Rust's standard library std.

ESP-IDF also Includes an implementation of FreeRTOS. So you can write proper async code, instead of complex timers to make things happen at the right time. Again, it's all about building cool projects without too much headache.

Books

Rust on ESP Book (book)

Embedded Rust on Espressif (book/training from Espressif)

Wokwi

Wokwi is like Codepen for embedded projects. It's one part website and one part VS Code extension. On the site, you can view, clone and create new projects, and use in-browser code editor and simulator to get a simple project running with no fuss. The VS Code extension basically integrates the simulator into your editor.

From their docs:

Wokwi simulates a wide variety of hardware components, including microcontrollers, sensors, displays, and more. It supports the following architectures: ARM, AVR, RISC-V, and Xtensa.

And there is a whole page dedicated to Rust projects. It's an awesome way to get started without buying anything! You can get started and have a blinking LED project in a couple seconds. And when you're ready, you can even flash your board directly from Wokwi.

Easy project setup

The esp-rs project has a set of project template that make creating new projects a breeze. You can use them with cargo-generate, and after answering a few questions, you'll be set up with either a no_std or std project, complete with configs Dev Containers that integrate with Wokwi simulator! You couldn't get much simpler.

Summary

So ESP32 checks a lot of boxes for me. It's an affordable, powerful microcontroller that has dev boards with lots of cool features. There is ample Rust support, and good learning resources. You can get started quickly with Wokwi, learn embedded development by building cool things. All without resorting to Python or C/C++.

See the original post over at my blog, Weekly Typed

First Thoughts on Zig - Getting Started and Learning Resources

Weekly Typed — Sun, 05 Feb 2023 15:10:45 +0000

This post originally appeared on Weekly Typed.

In January 2023, I delved into the Zig programming language. If that's unfamiliar, check out the website for a rundown of what it's about. The Road to Zig 1.0 is also a great talk by Andrew Kelley explaining why he created it. I had heard about Zig a while back but only got interested enough to learn it because the Bun runtime for Typescript/Javascript piqued my interest. And that project is written in Zig.

Anyway. Here are some initial thoughts I had trying to get started and learn the language.

Getting started

The getting started guide was beneficial. It was easy to install the zig compiler and toolchain on Mac (via Homebrew) and Windows (via Chocolatey).

I did run into one snag when installing extensions on VS Code. The guide mentions several options, but most people will probably want zls-vscode. I installed another extension by mistake, which only gave me syntax highlighting and a small amount of linting. Which is what the guide actually tells you if you read it. zls-vscode is a frontend for the Zig language service (zls). When you install it, you will be prompted to install zls. This gives you all the features of the other extensions and more.

Learning resources

Ziglings is a great way to learn the basics of the language. It is a repository with a series of one-file programs. At the top of each file, comments give you information about one concept in Zig. Each program is broken in some way related to that concept. Your goal is to fix it with the help of the comments.

There are a few things to know before going in.

First, Ziglings needs to be updated in places. Zig is not yet to version 1.0. So don't be too surprised if some field names of common types have changed, and Ziglings still needs to catch up.

Second, Ziglings only covers some things. Once you are done with it, give the docs a look. They are great and cover everything.

Because Zig is still so young, there are few other resources to learn from

That's it for now. In a future post, I will discuss my thoughts on some features of Zig. Some of them are familiar, but Zig does them differently. Others are very unique.

Error handling
Optionals
Unions
Types as values
Comptime

Compilers Could Be Way More Fun

Weekly Typed — Sat, 21 Jan 2023 18:37:50 +0000

This post originally appeared on Weekly Typed

I've had this idea kicking around in my head for a while.

For the past year, I've been slowly learning about compilers, DSLs, and language engineering. It's a lot to learn, for sure. But it's a lot harder given the resources available. Sure, there are textbooks, approachable books, some video series. But there just are not enough of them.

We need more voices to learn from

Many years ago, I decided to read a book by Tony Robbins. I don't remember the book, and I had too short of an attention span to finish the first chapter. But even in those few pages, I found something that's stuck with me. It's obvious, actually, but easy to forget.

To paraphrase him: sometimes you can hear the same thing explained 9 times by 9 different people and it still doesn't click. Then that 10th person explains it, and it all falls into place. They don't have to be particularly clever about it, either. Maybe they just think a little more like you.

Missing a modern approach

There are some other things that are just missing in the existing resources. For example, usually the project's build setup is glossed over. This makes sense, because it seems outside the scope of a book or video. But here's the thing. Even if I don't know the language you're using in your book, I can figure out what you're doing. But I might not have any clue how your build tools work. So if I have to debug your build script before I can start, you've lost me.

It would be nice to use some modern services to get people set up and working through a practical project. Something like gitpod or github workspaces would be a HUGE improvement! Or what about tools like Rustlings or Ziglings? This is starting to sound like a job for a community.

Compiler-nomicon

So that's what I'm going to try to build. The initial steps will be to create an open source document designed to help anyone understand (and build!) all the parts of a compiler. But I want to quickly expand from there, to include all kinds of topics related to language and compiler design. Not just the basics, and not just high-level. Advanced topics about real features you find in real languages.

For example, many books teach you how to build things like simple functions, methods, structs and classes into a new language. But what about enums, interfaces, traits, ownership, pointers, records, type classes, data classes, higher order functions, lambda/nameless functions, and so on. I want to get into that.

Around this documentation, I want to build a community of contributors. I want the code examples to be in as many languages as possible. If you're interested in helping, you can get involved a couple ways. You can either sign up for updates to this blog, leave a comment, or email me directly. See the about page of this site for the details. The documentation will be on github, so we'll coordinate there.

I'll have more to say on this soon. If you have any questions or feedback, sign up and comment!

Thanks for reading.

Playing with the Amethyst Game Engine

Weekly Typed — Fri, 22 May 2020 11:36:46 +0000

I realized today I had never tried game development, so I figured I would stay up too late and give it a go.

Entity-Component-System is an architectural pattern used in game development.

Every object in the game is an entity, which is made up of components that contain state.

Systems create the behavior by manipulating an entity's components.

That's my understanding anyway!

In this stream, I'm learning to build a pong-like game using the game engine Amethyst (https://amethyst.rs). Pretty great docs for beginners!

Built with Rust of course. :)

What do you wish companies would put in job listings?

Weekly Typed — Tue, 25 Jun 2019 16:19:07 +0000

Here's mine:

Please, please just tell me what tech stack you use in the listing!!!

Even better if you can give me an idea of what I would use. This is omitted all the time. It's understandable if you don't care if I have experience in your particular stack, but I still want to know what it is.

What would you like to see more of?