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.
Rust on an Arduino Uno, Part 5
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.
Rust on an Arduino Uno, Part 4
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!
Rust on an Arduino Uno, Part 3
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!
Rust on an Arduino Uno, Part 2
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:
Rust on an Arduino Uno
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.
Running dnsmasq on OS X and routing to virtual machines
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
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.
A final dip into Ruby’s Marshal format
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.
Another dip into Ruby’s Marshal format
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.
A little dip into Ruby’s Marshal format
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.