coreytabaka.com

I started investigating Lua recently and I must say there’s a lot to like. Lua has a very minimalistic syntax and an equally minimalistic standard library. This minimalism leads to two major advantages:

1. It’s very easy to integrate Lua into any environment because Lua’s minimalism demands very little support.
2. It’s very easy to extend Lua because it’s implemented in pure C, including the entire standard library – there are no support files to drag around.

Don’t be fooled by Lua’s apparently bare-bones syntax and standard library, Lua is a highly capable language, with all of the power of larger, more widespread languages. Lua reminds me a lot of JavaScript in that one can implement a lot of interesting and useful constructs that are not native to the language using a simple set of powerful primitives.

I could go into some examples here, but I’ll leave that for another post. Instead, go check Lua out for yourself!

www.lua.org

I just started using a very cool logic analyzer from Saleae. It’s a small-ish USB dongle with 8 or 16 probes (I have the more expensive 16 probe model). The software that drives the device is very slick and works on Mac OS X, Windows, and Linux — pretty impressive to see software of this kind supporting more than Windows (or Linux as an afterthought).

I find the built-in protocol analysis functions extremely useful: the current version of the software supports decoding data on various peripheral buses including SPI and I2C which are common in embedded systems. There is also an Analysis SDK for writing analyzer plug-ins to cover anything the vendor hasn’t already implemented. Very cool.

Another cool way to use the device is with the Device SDK, which is a set of libs that allows you to access the raw probe samples and write your own analysis tools. I can see this being very useful in some advanced QA automation in the future.

Best of all the price is very right! Even a casual hobbyist can justify the 8 probe model.

Go check the product out for yourself: http://www.saleae.com/logic/

Do you remember the old programming game, Corewar? Admittedly, it was a little before my time, but I’ve always been fascinated by the idea of writing competitive, pure programs. After doing a little research on the original Corewar, I decided to implement my own, but with a twist: instead of reusing the assembly-like language from the original or making up my own, I decided to use the ARM instruction set as the basis for my game. After a few weeks of hacking on a friend’s ARM emulator, I made a working prototype for a new Corewar.

As it turns out, ARM is a great instruction set for this purpose, having fixed size instructions and PC relative addressing. My design makes use of almost the entire ARM7TDMI instruction set, including THUMB, with a few synchronization and esoteric instructions omitted.

Hopefully I will have a polished version for public consumption some time in the near future (though I can never be sure how far out personal projects will end up).

I just learned about CoffeeScript today, while browsing twitter. Looks pretty neat. It’s interesting that JavaScript is being used a backend for other, more elegant, languages these days.

Check it out: http://jashkenas.github.com/coffee-script/

I would like to think that I have a thing or two worth saying. I have a personal blog, where I can share my thoughts and insights, and yet there is little content to be found. I think maybe this is a good sign!

Perhaps the relatively thin content of this site is an indication of my level of activity elsewhere. I wonder if I were doing less, would I have more time to write? I think so.

I would, however, like to share more of the exciting things I have been working on. Soon.

I decided to be a bit more proactive with publishing the source to my projects, so I installed Gitweb. You can accesses my projects at: http://coreytabaka.com/git

Due to the level of interest I’m getting in the source to the Cube Demo, I’m making an effort to clean it up and publish it. Look for it soon.

I recently found the old test VM I used for developing the Monarc PowerPC Emulator. VMware is a great platform to develop on, with support for GDB remote serial protocol and decent performance compared to straight emulators like Bochs or qemu. However, even with VMware’s superior performance, it was not fast enough to run a PowerPC guest OS interactively. But lately it seems that VMware, and of course computer performance in general, has made some significant improvements since I last tried running a PowerPC guest.

My most recent experience was surprising. My development machine is a 15” MacBook Pro, with 8 GB RAM, an Intel Core 2 Duo clocked at 2.93 GHz, and running Snow Leopard; nothing too shabby. I started up the VM in VMware Fusion 3.1 and was interacting with Mac OS X Panther in about 20 seconds. Amazing.

Now that I have a speedy platform to test and debug the emulator on, I’m going to have to dust off the source and start hacking on it again. For this round I think I will port it to my more recent kernel, which much more capable than the small embedded kernel I wrote originally.

Of course I’ll add some goodies to the project page as things progress.

I just picked up a set of Lego Mindstorms NXT 2.0. It’s a robotics kit based on the AT91SAM7S256, which is a rather nice ARM7TDMI based SoC.

Coincidentally, the little kernel (lk), written by Travis Geiselbrecht and being used as a bootloader for Android and webOS, supports AT91* platforms. Of course, this means I have to get lk running on the NXT.

I recently discovered a really cool tool called IDA Pro. It’s an interactive disassembler with some powerful features that make examining low-level code and debugging very easy.

I’m currently working on getting IDA Pro to talk to my Lauterbach JTAG Debugger via GDB Remote Serial Protocol, but it seems that there is a bug in the Lauterbach software. The two products should make a very powerful combination.

Check out IDA Pro at http://www.hex-rays.com/idapro/

I recently ported lk to the x86 PC platform. Lk (little kernel) is an embedded kernel written by Travis Geiselbrecht, with contributions from various others. More info here.