Task
  .StartNew(() => MakeSomeDecisionSlowly())
  .ContinueWith(result => ProcessResult(result));

You can simply say:

bool result = await MakeSomeDecisionSlowly();
ProcessResult(result);

While the two pieces of code are exactly equivalent, the second code is so much simpler to understand. Because you don’t really have to think about the fact that there is an asynchronous context switch going on, you are free to focus on your program’s logic, rather than worrying about manually orchestrating what tasks are doing what.

However, after using these features for several days while porting my KhanAcademy windows phone app to windows 8, I’ve come to approach them with a bit of caution. While they are great for low level IO-bound tasks, in my opinion they don’t scale well to higher level API design. A few things to watch out for:

If you use await somewhere in your code, then the containing method needs to be marked with the async keyword, and there are specific rules about return types. Namely, the method must either be void, or return Task<T>. For example, the example above would have to be in a method

public async void DoThatThing() { … }

Or, if you wanted to return the result of ‘MakeSomeDecisionSlowly’ back to the caller, it would have to look like this:

public async Task<bool> DoThatThing() { … }

Which is great, and all, but then it means that the calling method must be decorated with ‘async’ as well. If you are refactoring an existing codebase, this can have the effect of rippling up the inheritance chain with numerous (albeit small) changes … depending on the situation.

Ok, fine, maybe that’s not a huge deal; it’s kind of annoying but I can definitely deal with that kind of refactoring. The big problem I have with async/await is that outside of relatively trivial pieces of code, it can tend to wipe away many benefits of proper abstractions.

Let’s say you are implementing a remote API call, and you have several requirements:

• Process the results if
  • You have a network connection (common mobile requirement)
  • The server is reachable (what if you’re connected at starbucks, but haven’t accepted the wifi’s terms of use?)
  • The server returns a code 200 (bugs happen)
  • The server indicates that your credentials are ok (what if the user’s password expired, or was changed by the user on your website?)
  • The server’s json response indicates a successful request
• If any of the above conditions are false, notify the user of the problem (with specific text for the situation).

This is a very common scenario in any occasionally connected mobile application, and you can see that there are no less than five distinct decisions that need to be made during the course of an API call. If you use async/await blindly, you have two problems:

First, you are deferring these decisions to the caller … you’ll do a nice asynchronous call, and return a Task<string> with the json results; or if you’re sophisticated, a Task<T> with the results already parsed and converted to a strongly typed object. However, it’s up to the caller to handle exceptions, check for network connections, deal with individual response scenarios (logged out, invalid request, etc.). So you may end up with every call site looking like this:

if (HasConnection())
{
  try
  {
    MyObject result = await MakeRemoteAPICall();
    ProcessSuccessfulResult(result);
  }
  catch(Exception e)
  {
    ProcessError(e.Message);
  }
}
else
{
  ProcessError("No Connection");
}

Second, providing further abstractions is difficult because you are limited to a single return type. So if you want to handle all of the stated requirements for the caller, you will have to wrap up the result in a special return value that can provide some details to the user, such as ‘was it successful’, the error message if it wasn’t, and the parsed return value if it was. While the pros and cons of using error codes for return values have been debated for ages; I tend to prefer simpler return values for local APIs, since a complex return value adds an additional burden on the caller to know how to interpret the results. At best, every call site would look something like this:

Result<MyObject> value = await MakeRemoteAPICall();
if (value.WasSuccessful)
{
  ProcessSuccessfulResult(value.Result);
}
else
{
  ProcessError(value.ErrorMessage);
}

That’s a bit better than before, but still rather verbose for my taste.

I propose that the callback style of API design still has a place for situations like this. Consider the following sample:

MakeRemoteAPICall(
  result => ProcessSucessfulResult(result),
  error => ProcessError(error));

For the local consumer of this API, this is logically the same: if the call was successful do this, otherwise do that. But the caller doesn’t have to worry about all the nuances of deciding whether a call was successful or not. They can focus on how to process the results, rather than dealing with all of this ceremony. And after all, isn’t that what we’re all aiming to do, simplify our code?

I would love to hear thoughts about how this kind of code can be made even simpler. Would love to hear any opinions, for or against. Thanks!

edit: lively debate over on Reddit http://www.reddit.com/r/programming/comments/txhfq/the_problem_with_c_5s_asyncawait_pattern/

The mono versions are using the silverlight version of the API, which uses async style methods where you pass in callbacks. There are two dependencies: RestSharp, and json.net. Though it looks like RestSharp has shed their dependency on json.net, there are still some references in the twilio code. The json.net project maintain mono specific versions … they depend on a portable library for that cross platform support. Unfortunately that means that you can’t compile it if you’re on a mac and only using monodevelop. Thankfully I found this helpful fork that did this work for me.

At the risk of  ‘pushing’ my pull request onto them, I submitted a pull request; But I made sure to word it such that I’m ok if they want to push back and ask for any changes … or maybe they don’t want to maintain a Mono version at all, in which case I’m happy to keep it in my fork. So we’ll see what happens. Please let me know if you have any feedback on this change.

As an aside, I also noticed while I was looking around github that many projects that have mono versions tend to use *.MonoTouch and *.MonoDroid for their project/solution names. It’s a subtle thing, but  Xamarin is careful not to refer to their product as MonoDroid, but Mono For Android. I wonder if this has to do with the trademarks that are owned by Lucasarts, if so I’d hate to wake up to a nice C&D in the mailbox

So I copied the file into my xml folder, and wrote this simple parser that reads the file in, and parses it into a HashMap

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>key1</key>
	<array>
		<string>one</string>
		<string>two</string>
	</array>

	<key>key2</key>
	<array>
		<string>one</string>
		<string>two</string>
	</array>
</dict>
</plist>

package cyborg;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.content.Context;

/**
 * This class parses an iOS plist with a dict element into a hashmap.
 */
public class XmlMapParser {
	private XmlPullParser parser;

	public XmlMapVisitor(Context context, int xmlid) {
		parser = context.getResources().getXml(xmlid);
	}

	public HashMap<String, ArrayList<String>> convert() {
		HashMap<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();

		final String KEY = "key", STRING = "string";

		try {
			parser.next();
			int eventType = parser.getEventType();
			String lastTag = null;
			String lastKey = null;

			while (eventType != XmlPullParser.END_DOCUMENT) {

				if (eventType == XmlPullParser.START_TAG) {
					lastTag = parser.getName();
				} 
				else if (eventType == XmlPullParser.TEXT) {
					// some text
					if (KEY.equalsIgnoreCase(lastTag)) {
						// start tracking a new key
						lastKey = parser.getText();
					}
					else if (STRING.equalsIgnoreCase(lastTag)) {
						// a new string for the last encountered key
						if (!map.containsKey(lastKey)) {
							map.put(lastKey, new ArrayList<String>());
						}

						map.get(lastKey).add(parser.getText());
					}
				}

				eventType = parser.next();
			}
		} catch (XmlPullParserException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return map;
	}
}

The way I look at it, may as well reuse what we’ve got, and spend less time yak shaving (ie. translating between platforms) … git ‘er done!

• Overly complex to support N number of different trackers … enterprise software at it’s “best”
• Binary distribution is only via MSI installer! seriously, in this day and age, either give me a NuGet package, or at worst just give me the .dlls.
• Even though it’s open source, looking through the code is an exercise in futility (see point 1). I considered going in and extracting just the code for GA, but it’s not even obvious where that is in the codebase … admittedly, I only browsed around through the online codeplex browser.

Thankfully, Justin asked me yesterday about adding GA to his MonoDroid project. I hesitantly pointed him to the MSAF library, but kept searching when I finally came across Maarten Balliauw‘s sweet implementation of a GoogleAnalyticsTracker for asp.net mvc. He was able to quickly adapt the code for his monodroid project; and because GitHub is awesome, I also forked it and added a new project that lets you build the solution for Windows Phone. You can find it here: https://github.com/joelmartinez/GoogleAnalyticsTracker

And then sent back a pull request for the changes That’s the great thing about open source, done GitHub style. I’m free to make (and share) the changes I need … and if they are good enough, they can easily make their way back into the original/main project. Awesome.

Edit: Maarten quickly accepted my pull request, and even adjusted the NuGet package to include the windows 7 build. With that, I deleted my fork as I wasn’t planning on making any additional changes in the immediate future. So you can find the latest here: https://github.com/maartenba/GoogleAnalyticsTracker

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