An algorithm has been developed to asynchronously load, unload, play and relocate sound files without the use of locks. The algorithm allows the programmer to arbitrarily assign different logical subsections of the underlying system to different threads, all while remaining completely lock-free.

 

An example implementation has been developed that asynchronously loads and unloads sound files in one thread while playing and relocating the same sound files in another thread. All of this happens in a single shared memory heap, all without locking. A complete working version of this system will be described, highlighting the simple yet elegant design principles.

Here's an internal presentation I gave just about a year ago on using wavelets for image compression. A nice and gentle introduction to a subject that's really pretty simple that is often buried under so many details that people don't know how to approach learning it.

A basic introduction to the concept of a colorspace for artists, programmers, and anyone who's just curious about the meaning of terms like "sRGB, "gamma," and "color profile." Talks about where colorspaces come from, what they look like, and why you might need to think about them.

The Dynamic Component System is now firmly established in our gameplay architecture. We’ve realized substantial benefits in workflow and performance from implementing gameplay as Dynamic Components. In this presentation, I provide a brief introduction to a few gameplay systems of Dynamic Components.

This presentation was an introduction to solving concurrency problems. In particular it was about breaking down previously held beliefs and approaches that in fact make multi-threading and multi-core problem solving seem much more difficult than it actually is. The key is understanding that concurrency is not a code problem, it's a data problem. It always comes back down to the data. I used a doubly-linked list as a reference point in this presentation in order to demonstrate that the "classic" data structures are actually "sequential" data structures and that by looking at concurrency problems from a data design point of view you'll find that those data structures in general, and doubly-linked lists in particular are *not* concurrent data structures. Certainly you can make them work, as many people have, but you're forcing an inherently sequential data design into a concurrent system and you're going to be paying a price in terms of both added complexity and performance loss. These slides are hopefully readable on their own. So enjoy! And remember we're always happy to get feedback.