Did a fun bit of hacking, ported the Jint JavaScript interpereter to Windows Phone 7.5 … the result is seen below:

var engine = new JintEngine();
engine.SetFunction("alert", new Action<string>(t => MessageBox.Show(t)));

engine.Run("alert('Hello World, from dynamically interpereted JavaScript on WP7!')");

And when we run that code in a silverlight application:

This would also work in XNA games for wp7, so one can imagine scripting scenarios if that’s your cup of tea. Though it would take more work for this to be supported on the xbox since DynamicMethod is not supported there.

I was really happy to see that Windows Phone 7.1 (Mango) brings in support for the DynamicMethod and some of the other Reflection.Emit features. One of my previous projects (New LateBinder) showed significant perf benefits to using this over regular old reflection.

I had to overcome some quirks due to the slight differences in the compact framework, but after some time I got it all working … so far all my tests have been successful (though it’s not to say it’s all fully working). Many props to the team of developers that did this over at codeplex.

• Socially Aware XBox Live Games
• Finite State Machine
• nBayes

Most recently, I’ve enrolled for the AI and Machine learning classes being offered by Stanford. I truly feel as if advanced engineering practices such as machine learning and AI are going to be what separates the good companies from the truly great companies over the course of the next decade. So far, these classes have great introductions if you’ve never been exposed to the fields, and promise to go much deeper.

I’m very glad that this online education movement, which was legitimized by Khan Academy IMO, is gaining momentum. Soon, the whole world will have easy access to even the most advanced topics … the future will be ours to create, if only we step up to the challenge.

In the meantime, if you’re interested you should get started by watching the intro lectures, and (at least in the case of the ML Class) installing Octave: http://www.gnu.org/software/octave/

Igor showed off the awesome new voice logging feature that we recently added to the iPhone version of the app (coming soon to the Android version). Then I manned the keyboard to show off a little hack that we put together that same day. We provisioned a Twilio phone number, and let the user record a little 10 second clip of what they want to log (ie. “one banana, two cups of coffee”). We then took that clip and sent it to iSpeech who transcribed it. And finally we ran the transcribed text through our own API to log it.

Igor asked the crowd to call in the phone number, which they did, and it worked! It was a great experience, and a fun day. Many thanks to Hal Rotholz as well as he was instrumental in getting this hack up and running, in addition to monitoring the server while we were up there

using System;
using System.Threading.Tasks;

namespace Life
{
    public class LifeSimulation
    {
        private bool[,] world;
        private bool[,] nextGeneration;
        private Task processTask;

        public LifeSimulation(int size)
        {
            if (size < 0) throw new ArgumentOutOfRangeException("Size must be greater than zero");
            this.Size = size;
            world = new bool[size, size];
            nextGeneration = new bool[size, size];
        }

        public int Size { get; private set; }
        public int Generation { get; private set; }

        public Action<bool[,]> NextGenerationCompleted;

        public bool this[int x, int y]
        {
            get { return this.world[x, y]; }
            set { this.world[x, y] = value; }
        }

        public bool ToggleCell(int x, int y)
        {
            bool currentValue = this.world[x, y];
            return this.world[x, y] = !currentValue;
        }

        public void Update()
        {
            if (this.processTask != null && this.processTask.IsCompleted)
            {
                // when a generation has completed
                // now flip the back buffer so we can start processing on the next generation
                var flip = this.nextGeneration;
                this.nextGeneration = this.world;
                this.world = flip;
                Generation++;

                // begin the next generation's processing asynchronously
                this.processTask = this.ProcessGeneration();

                if (NextGenerationCompleted != null) NextGenerationCompleted(this.world);
            }
        }

        public void BeginGeneration()
        {
            if (this.processTask == null || (this.processTask != null && this.processTask.IsCompleted))
            {
                // only begin the generation if the previous process was completed
                this.processTask = this.ProcessGeneration();
            }
        }

        public void Wait()
        {
            if (this.processTask != null)
            {
                this.processTask.Wait();
            }
        }

        private Task ProcessGeneration()
        {
            return Task.Factory.StartNew(() =>
            {
                Parallel.For(0, Size, x =>
                {
                    Parallel.For(0, Size, y =>
                    {
                        int numberOfNeighbors = IsNeighborAlive(world, Size, x, y, -1, 0)
                            + IsNeighborAlive(world, Size, x, y, -1, 1)
                            + IsNeighborAlive(world, Size, x, y, 0, 1)
                            + IsNeighborAlive(world, Size, x, y, 1, 1)
                            + IsNeighborAlive(world, Size, x, y, 1, 0)
                            + IsNeighborAlive(world, Size, x, y, 1, -1)
                            + IsNeighborAlive(world, Size, x, y, 0, -1)
                            + IsNeighborAlive(world, Size, x, y, -1, -1);

                        bool shouldLive = false;
                        bool isAlive = world[x, y];

                        if (isAlive && (numberOfNeighbors == 2 || numberOfNeighbors == 3))
                        {
                            shouldLive = true;
                        }
                        else if (!isAlive && numberOfNeighbors == 3) // zombification
                        {
                            shouldLive = true;
                        }

                        nextGeneration[x, y] = shouldLive;

                    });
                });
            });
        }

        private static int IsNeighborAlive(bool[,] world, int size, int x, int y, int offsetx, int offsety)
        {
            int result = 0;

            int proposedOffsetX = x + offsetx;
            int proposedOffsetY = y + offsety;
            bool outOfBounds = proposedOffsetX < 0 || proposedOffsetX >= size | proposedOffsetY < 0 || proposedOffsetY >= size;
            if (!outOfBounds)
            {
                result = world[x + offsetx, y + offsety] ? 1 : 0;
            }
            return result;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            LifeSimulation sim = new LifeSimulation(10);

            // initialize with a blinker
            sim.ToggleCell(5, 5);
            sim.ToggleCell(5, 6);
            sim.ToggleCell(5, 7);

            sim.BeginGeneration();
            sim.Wait();
            OutputBoard(sim);

            sim.Update();
            sim.Wait();
            OutputBoard(sim);

            sim.Update();
            sim.Wait();
            OutputBoard(sim);

            Console.ReadKey();
        }

        private static void OutputBoard(LifeSimulation sim)
        {
            var line = new String('-', sim.Size);
            Console.WriteLine(line);

            for (int y = 0; y < sim.Size; y++)
            {
                for (int x = 0; x < sim.Size; x++)
                {
                    Console.Write(sim[x, y] ? "1" : "0");
                }

                Console.WriteLine();
            }
        }
    }
}
, 

The included sample program that uses the ‘LifeSimulation’ class initializes the a simple blinker, and then generates and outputs 3 generations.

The new position is with About.com, working in their Calorie Count business unit on their Android app. The app was recently featured on TechCrunch, covering a new feature which came to the iOS version. I will be working to bring that feature and others to the Android version.

This is of course a bit of a departure for me, professionally speaking. Having lived most of my professional life working with Microsoft technologies; I see it as a huge opportunity to broaden my horizons, and experience a different perspective. So far, Java hasn’t been that tough to pick up, and the Android SDK is easy enough to work with.

The team I will be working with has a radically different culture than I’ve seen in many places. For example; Although it’s part of a larger organization, the business unit is run somewhat as a startup. They even meet at NewWorkCity on Wednesdays just to change things up. This appeals to me a great deal, and I look forward to operating in an environment that eschews traditional corporate processes in favor of getting results.

I’ve learned a great deal in the last 5 years. And I’ve come away from the experience with some of the best friends and most trusted colleagues. Also, just because I’ll be doing some Android programming now, I still love XNA, and I still love my Windows Phone … I will probably just have a few extra gadgets on my persons from now on

Now Available for the Windows Phone Marketplace, SteamBirds:

The turn-based aerial combat game that over twelve million people have played!

"…Steambirds lies in wait to rob you of your Monday morning." –Penny Arcade

Use bombs, missiles and poison gas to defeat enemy planes in this unique turn-based game! This version features improved graphics, new music, and local multiplayer mode.

There’s already a few reviews in the marketplace, my favorite is:

OMG!!!!!!! THE Steambirds is out!!! I’ve played this game in flash,now it’s out for wp7. A must have game for RTS lovers. Runs perfect & smooth [… snip …] 10 out of 5 stars!!!

As with Udder Chaos, this game was built with FlatRedBall. Many thanks to Vic and the rest of the team involved for the opportunity to work on this game. Lots of exciting things on the horizon

Now available on the Windows Phone marketplace, Udder Chaos!

“Protect your cows from Alien hordes as they try to abduct your precious livestock. Alien hordes too hard? Upgrade your weapons and gain smart bombs to blow them out of the sky.

Includes global leaderboards, endless mode, easier kid-mode, and option to remove ads.”

The trial is completely fully featured and ad-supported … and if you purchase the game, all ads are removed.

If you’ve got an XBox 360, you can also download Udder Chaos on the XBox Live Indie Games channel!

So I added a ParallelExample project to the solution and started experimenting. The end result is an easy to use class called SequentialActionQueue. Usually when you need to synchronize access to a resource, you end up putting a lock section around your code so that only one thread may access it at a time. However things get more complex if you need to synchronize multiple sections of the code (ex. multiple methods in a class where only one may run at a time). This is classic thread-safety issues, and the dragons that lie in those waters. However, With the SequentialActionQueue, you can simply instantiate the class and proxy all actions through it and be guaranteed that everything will run safely one after the other.

private SequentialActionQueue queue = new SequentialActionQueue();
private int counter =0;

public void Add(int i)
{
    queue.Enqueue(() => counter += i);
}

public void Subtract(int i)
{
    queue.Enqueue(() => counter -= i);
}

The above is a simplified example which emulates the ability to use Interlocked to safely increment/decrement a number. I’d love to get some thoughts on the class … I wrote a few tests in the sample project, but that’s not to say there won’t be bugs in it, would love to hear your feedback
 

.SYNOPSIS
Executes SQL against the supplied connection string.
.DESCRIPTION
Executes SQL against the supplied connection string. The result set is then pipelined as a PSObject which can subsequently be formatted and filtered any way you choose.
.PARAMETER query
The query to execute
.PARAMETER connstring
The connection string to use
.EXAMPLE
PS C:\> Exec-Sql -q "select top 1 * from common.country" -conn ""
.EXAMPLE
PS C:\> Exec-Sql -q "select * from common.country (nolock)" -conn "" | where {$_.Code -eq "AX" } | select code, name
#>
function global:Exec-Sql
{
param ([Alias("q")]$query, [Alias("conn")]$connstring)

[system.reflection.assembly]::LoadWithPartialName("System.Data")
$connection = New-Object -TypeName System.Data.SqlClient.SqlConnection

$connection.ConnectionString = $connstring
$connection.Open()

$command = New-Object -TypeName System.Data.SqlClient.SqlCommand

$command.Connection = $connection
$command.CommandText = $query
$reader = $command.ExecuteReader()

$fieldcount = $reader.FieldCount

while ($reader.Read())
{
$o = new-object psobject

for ($i=0;$i -lt $fieldcount;$i++)
{
$o | add-member -membertype noteproperty $reader.GetName($i) $reader[$reader.GetName($i)].ToString()

}

write-output -inputobject $o
}

$connection.Close()

}