We can’t yet compile the stock version of libcore, so in the meantime we have our own version with the essentials. Because we’ve directly added this code to our project, each recompile takes a while. It’d be really nice if we could use Cargo like a Real Rust Project would, allowing us to compile our modified libcore once and reuse it.

Previously, we wrote some code that allowed us to sleep by waiting for a number of cycles to pass. However, we had to peek at the disassembly to know how many cycles we were spending and adapt our source code to match. While it got us started, it’s not a very elegant solution.

When we left off, we were blinking the LED. Let’s take a brief detour and document how to get a working Rust compiler. This is mostly a way for me to document what I’ve been doing so I can find it again!

Now that we can turn an LED on, let’s see if we can do something more exciting: make the LED blink. Surprisingly, this is more difficult than you might expect!

After my previous attempt, I started to think that the issues were caused by an inability to completely link the program. If that were the case, could we try to link in a different way?

Through a bit of trial and error, I was able to generate an object file:

1

rustc --target avr-atmel-none hello.rs --emit obj

We have an Arduino Uno that’s been sitting around gathering dust for a little while, so I decided to see how Rust worked on it.

At work, I needed to run a Docker container with a Rails application that talked to another application running inside a VMWare virtual machine. Adding to the complexity, I use boot2docker, which runs inside of VirtualBox.

If I only needed to access rails.localdomain.dev or api.localdomain.dev from my Mac, I could have simply edited /etc/hosts and set both domains to resolve to 127.0.0.1 and been done with it. Unfortunately, Rails needed to be able to directly resolve the API server.

This is the third and last of my posts about the Marshal format. The first part introduced the format and some straight-forward serializations. The second part touched on strings and object links. This post rounds us off with regexes, classes, modules, and instances of objects.

In a previous post I started to describe some details of Ruby’s Marshal format. This post goes further: a larger set of integers, IVARs, strings, and object links.

I recently tried to resolve a JRuby issue involving Marshal. I’ve used Marshal before, but never needed to pay attention to the actual bytes written to disk. I decided to write up what I learned in the process.