• 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.

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
 

public static class WebHelper
{
    public static WaitHandle Get(string url, Action<WebResponse> action)
    {
        return Get(new Uri(url), action);
    }

    public static WaitHandle Get(Uri uri, Action<WebResponse> action)
    {
        var request = WebRequest.CreateDefault(uri);
        ManualResetEvent handle = new ManualResetEvent(false);
        request.BeginGetResponse(i =>
        {
            var response = request.EndGetResponse(i);
            action(response);
            handle.Set();
        }, null);

        return handle;
    }

    public static WaitHandle Get(string url, Action<string> action)
    {
        return Get(new Uri(url), action);
    }

    public static WaitHandle Get(Uri uri, Action<string> action)
    {
        return Get(uri, response =>
        {
            var sreader = new StreamReader(response.GetResponseStream());
            var result = sreader.ReadToEnd();
            action(result);
        });
    }
}

For some example usage, you can easily proxy a download through an ASP.NET MVC web app:

        public ActionResult Get(string q)
        {
            Stream res = new MemoryStream();
            string contentType = "text/html";

            bool timedOut = !WebHelper
                .Get(q, html =>
                    {
                        res = html.GetResponseStream();
                        contentType = html.ContentType;
                    })
                .WaitOne(30000); // wait 30 seconds to get a response

            if (timedOut)
            {
                StreamWriter writer = new StreamWriter(res);
                writer.WriteLine("The request timed out, sorry!");
                res.Seek(0, SeekOrigin.Begin);
            }

            return File(res, contentType);
        }

Despite the social weight of these already existing services … there is still a lush breeding grounds for innovation in location services. If you were building such a service, let’s talk about the process of defining a “new place” as a user. What happens if the first user of your app to create a place is actually just around the corner, or if the place is large enough, on the east side rather than the west side. In a naively designed system, your place would be incorrectly defined from that point forward and would offer incorrect position data for the life of your service.

This post proposes a simple system that lets the place’s location in the world adjust itself over time. The more checkins you receive, the more accurate the location.

The concept is quite simple actually, by computing the centroid from all known checkins, you find the true ‘center’ of you place. Doing this calculation could not be any simpler, centroid is just a fancy term for the average vector from a set (ie. Lat/Lon)

I made a useful extension method that you can apply to a collection of vectors which can be invoked as such.

Vector2 centroid = locations.Centroid();

public static class VectorExtensions
{
    public static Vector2 Centroid(this List<Vector2> points)
    {
        int pointCount = points.Count;
        Vector2 total = Vector2.Zero;
        Vector2 centroid = Vector2.Zero;

        if (pointCount > 0)
        {
            for (int i = 0; i < pointCount; i++)
            {
                var point = points[i];
                total.X += point.X;
                total.Y += point.Y;
            }
            centroid = new Vector2(
                total.X / (float)pointCount,
                total.Y / (float)pointCount);
        }
        return centroid;
    }
}

So given a set of points, this would easily give you the logical center of them. Even if there’s a random checkin from outside the area, the average will not let the centroid vary by much.

But there is still an issue with this approach. How can this techique be applied to a real world system, you can’t expect me to keep a copy of every checkin ever done for a given location … I mean you can, but for most purposes it’s overkill.

Luckily, there is a way to reduce the problem domain to limit the amount of data needed to recalculate the centroid every time there is a new point to consider. By doing a weighted average, your data structure is greatly simplified because all you have to keep in the database for any given location is:

• latitude
• longitude
• numberOfCheckins

With that, you can find your list of closest places to let the user see if their location is already in the db.

If the user selects an existing place to check in to, you can calc the centroid as follows:

public static Vector2 WeightedCentroid(
                                                this Vector2 newPoint,
                                                Vector2 oldCentroid,
                                                int numOfCheckins)
{
    return new Vector2(
        (oldCentroid.X * (float)numOfCheckins + newPoint.X) / ((float)numOfCheckins + 1),
        (oldCentroid.Y * (float)numOfCheckins + newPoint.Y) / ((float)numOfCheckins + 1)
        );
};

With that, you can save the value of the new average, along with the latest number of checkins. And that’s it!

You can download it by clicking here if you have the Zune software installed, or just navigating to Marketplace > Books &  Reference > Reference, or of course, just searching the marketplace for “Khan Academy”.

This has been a great learning experience, and I hope to continue working with the Khan Academy to iterate and improve on the application based on user feedback. If you do have feedback, please don’t hesitate to leave a comment, email me, or create a discussion on the codeplex site. And of course, Rate and Review the application after you download it

I’ve been extremely impressed with the quality and value of the videos since I discovered the site a few years ago. And it was no surprise when Bill Gates called Sal Khan his favorite teacher.

I wanted a way to contribute to the cause, and with Microsoft’s new platform just launching, and the fact that I wanted a project to focus on for the Windows Phone it seemed a natural fit.

In keeping with the spirit of the Khan Academy’s open source development ethos, I am making this project open source as well on CodePlex:
http://khanviewer.codeplex.com/

I plan on maturing the app over time with better styling, and more features, especially as I learn more about the silverlight/phone platform. The project is almost ready to submit to the marketplace, just need to complete a bit more testing … so keep an eye on this space for more info about when that happens.

string filepath = @"c:\users\joel\downloads\loanstats.xml";

XDocument xml = XDocument.Load(filepath);
var loansElements = xml.XPathSelectElements("//loan");
var loans = loansElements.Select(x => new
    {
        Id = x.Attribute("id").Value,
        AmountRequested = x.Attribute("amount-requested").Value,
        InterestRate = x.Attribute("interest-rate").Value
        // and so on
    });

foreach (var loan in loans)
{
    Console.WriteLine("{0} - {1} @ {2}", loan.Id, loan.AmountRequested, loan.InterestRate);
}

They also have each data file available as a CSV if you prefer to do things that way.

public static class WebHelper
{
    public static void Get(string url, Action<string> action)
    {
        Get(new Uri(url), action);
    }

    public static void Get(Uri uri, Action<string> action)
    {
        var request = WebRequest.CreateHttp(uri);

        request.BeginGetResponse(i =>
        {
            var response = request.EndGetResponse(i);
            var sreader = new StreamReader(response.GetResponseStream());
            var result = sreader.ReadToEnd();
            action(result);
        }, null);
    }
}

Using this class could not be easier:

string u = @"http://bing.com";
WebHelper.Get(u, html =>
    {
        Debug.WriteLine(html);
    });

This class can (and will) be expanded for things like posting form values … I’ll update this post if I do any of those updates