Sapien Coder

September Garmin Forerunner 310XT Giveaway

2010-09-02T08:32:00.001+03:00

DC Rainmaker is giving another Garmin 310XT.
Hurry and sign up:
http://www.dcrainmaker.com/2010/09/september-garmin-forerunner-310xt.html

Better yet, don't sign up, so I have a better chance of winning :-)

DCRainmaker is Giving Away a Garmin 310XT

2010-08-05T09:55:00.000+03:00

Check out all the details here:
http://www.dcrainmaker.com/2010/08/garmin-forerunner-310xt-giveaway.html

Another Giveaway from DCRainmaker

2010-07-02T14:58:00.001+03:00

This month Ray is giving away a Garmin Forerunner 110!
Cool indeed.
check out the details on his blog.

DC Rainmaker is giving out a free Wifi Scale

2010-06-02T11:34:00.002+03:00

Just thought you'd like to know...
Here is a link to the giveaway:
http://www.dcrainmaker.com/2010/06/withings-wifi-scale-giveaway.html

Navigate with the Garmin Forerunner 305

2009-06-07T21:30:00.003+03:00

A couple of weeks ago, one of my riding buddies invited me to join him on a training ride to prepare for the Jerusalem Marathon. The idea was to ride one lap around the 30 KM course to get to know it before the actual race. Since neither of us ever rode that course before, he asked me if I could add it to my Forerunner 305 GPS and use it to show us the way.

I love my Garmin FR305. I use it all the time for training. It provides me with lots of information about my runs/rides both during and after workouts. But it has never occurred to me that I could use it for navigation. So I did some research online (there's not much information on the official Garmin site) and found a few tutorials that explain the process. Since I couldn't find anything detailed enough, I thought I'd write my own take of it and share it with my readers. So here goes...

To get started you'll need to get a hold of a course file. There are many tools and sites that let you create a course file by drawing a route on a digital map and saving it locally, where the most common is Google Maps. In Israel, you can use Amud Anan to draw the course on a topographic terrain map (Google Maps does not provide topographic information for Israel yet) and save it to your computer. You can also download an existing course file from a plethora of sites that store and categorize routs for hiking, running, biking etc. and let users upload and share their own routs. There's btrail, USATF, MapMyRun, MotionBased Trail Network just to name a few.

The important thing is to store the file in the correct format for the Forerunner 305 which is a .crs file (remember, this is a course file, not a workout file). There are a ton of different file formats for the different GPS devices and tools, but luckily it's easy to convert from one format to another using this conversion tool. Just point to your source file, select the format you're interested in (Garmin Course CRS) and hit Convert. If you choose Options, you can also name the course, and add/fix elevation data to your course.

Once you have the CRS file stored, open Garmin Training Center, and choose File -> Import -> Courses. Select the course file, and voila, your file is right there under the Courses tab. Now connect your FR305 and click on the "Send to Device" button to transfer the new course to your Garmin Forerunner.

Once the course is on the device, click Mode, then choose Training, Courses and select the course you want to follow. Click Do Course to start. The timer does not actually start until you press the normal Start button.

In navigation mode, the FR305 provides screens that are unavailable in standard training mode: navigation data fields, map view, elevation graph, compass, etc. You switch between the "special" screens using the Mode button, and the standard screen using the regular up/down arrow keys.

The most useful screen in my opinion is the map screen. It shows the planned course in a thick line, and the actual traveled track in a thin dotted line, and the current location is shown using a small triangle. This screen makes it very easy to follow the planned route.

One complaint I have about navigating with the FR305 is that it displays a "Off Course" message too often, even when I'm on course or off by a tiny bit. the problem is that the Off Course message stays there until you hit the Enter button which could be difficult in the middle of a hard climb or a fast descent. And while the message is on screen it is hard to see the data behind it.

Other than that, it's a great way to explore new trails without getting lost.

The Evolution of My Mountain Biking

2009-05-23T15:30:00.003+03:00

If you've read my previous post about running gadgets, you've probably assumed that I'm a runner. Well, I am now, but I wasn't always one. My true love has always been mountain biking. More accurately - my current true love is mountain biking. Before that it was BMX, and before that offroad dirt bikes. I guess I just love anything with two wheels and handlebars. I've been riding bikes since forever, and mountain bikes since 1994. I can't remember a time in my life when I didn't own a bike or two. Maybe only during my 4 year military service.

A few hours ago I came back from an epic ride with my friends. It's the same group of people I've been riding with for the past three years. The ride was awesome! We headed out to the Jerusalem mountains for some fast cross-country riding with lots of long steep climbs combined with a couple of classic single tracks. When I look at my friends I'm amazed to see how much our riding has changed in the last couple of years. These days most of us are riding steel hard tail bikes with no gears. It's a long leap sideways from the high-tech aluminum long-travel full-suspension bikes we all owned and rode just a few short years back. But I'm moving too fast here, let me start from the beginning.

The bike that I consider to be my first "real" mountain bike was a rigid 1994 Kona Lava Dome. It was 2 sizes too big, and was very very, well, rigid. But I loved it. It was fast and light, and climbed like there was no tomorrow. It had a beautiful cromoly frame, Grip Shift shifters, cantilever breaks (which were a pain to adjust) and flat, narrow handlebars - SWEET! The reason I bought it (not that I really needed a reason) was to commute to my school which was located smack in the middle of the Carmel mountains in Haifa. To grab some extra credit I joined the school's mountain biking team, which meant I had to attend the team's weekly early morning rides (rain or shine) to the Haifa University which was all the way up the mountain. We took the road going up, and once we got there we chose one of the numerous fire roads that lead back down and just raced down full speed ahead - no single tracks, no technical trails, just full-on speed that, on a rigid bike, would loosen the fillings in your mouth and blur your vision. Most of the time it also meant climbing back from the bottom of the mountain to the Technion's campus which was about half way up. By 8:30 when class started, we'd be back in school all sweaty, smelly and - depending on the weather - soaking wet, but with huge smiles on our faces. This is what got me hooked on mountain biking.

Around 1998, a little after I graduated form university, I traveled to visit my kid brother in Canada. We went on a roadtrip through the Canadian Rockies. On one stop along the way, I think it was in Lake Luise, my brother and I rented mountain bikes and went for a short ride in the trails around the lake. It was the most beautiful bike ride I've done until then - long winding single track in deep green woods that seemed to last forever. Absolutely perfect. When we got back to the store to return the bikes I noticed that they were having a huge end of season sale (it was the end of summer) on all their new bikes. I just couldn't resist, and bought my first full-suspension bike - a DeVinci Magma. Or Contact. I forget. What I do remember is that I actually tried out two different bikes: an XC race-ready hard tail, and a more moderate full-suspension FSR style bike. I almost went for the hard tail just because it had an XTR rear derailleur. Plus, full-suspension bikes weren't very common back then, and I was afraid of being an early adopter. What a dope. Luckily I wasn't fooled by the bling of the XTR, and went for the full-suspension bike. Apart from the XT rear derailleur it also had a RockShox Judy 80mm fork, 3.25" of rear wheel travel, V-breaks and a wide Titec riser bar which I had cut by an inch on each side (once again, what a dope). I remember coming home with the new bike and taking it in for a tune-up at the local bike shop, the bike mechanic was so impressed with the suspension, he suggested I sign up for the upcoming downhill race! I'm glad I didn't listen to him... I enjoyed riding the DeVinci very much, but didn't quite know what it was best for. I took it out to the most technical single tracks available at the time (mostly motorbike enduro trails), and was surprised the bike didn't handle them very well. What was I expecting? Anyway, at the time motorbikes started grabbing more and more of my attention, and the poor bike was left alone to collect dust on the porch while I rode the same trails on a 2 stroke KTM.

Motorbikes came and went, and one day in late 2003 I noticed a new trend: everybody around me was talking about, or buying all mountain bikes. So, I decided to join the long travel revolution (what can I say, I'm a trendy guy), and bought a Rocky Mountain Slayer 70 with 5 long, plush inches of front and rear travel. Finally, I thought, a bike that can handle anything I throw at it. It was the bike that got me riding mountain bikes again. Biking in Israel was taking off like crazy, new trails were popping up everywhere, and everyone I knew was riding bikes. The new trails were getting more and more technical with rock drops, jumps and steep downhills. There were even a few trails that had wooden bridges, ladders and jumps built along them a-la North Shore. In most cases I handled the technical elements quite well with my Slayer, but I was starting to feel a bit inadequate. Everywhere I looked 6 and 7 inch bikes were roaming the trails, riders wearing full-face helmets and body armor were sharing the same trails I was, taking crazy lines down the mountain sides. It was getting just too tempting. So once again, in late 2007 I said goodbye to my Slayer and bought a new bike: a DeVinci Frantik. This time a full-fledged freeride bike. It had a coil spring, a beefy 180mm single crown fork, 1.5" head tube and it weighed 18KG. A freaking beast - and I loved it. This time there were no excuses, I rode everywhere, down the gnarliest trails and the craziest drops. And I did it all with relative ease. This bike was awesome, it made me a better rider by providing stability and security in the most difficult and unpredicted places. It showed me that I can actually do and dare more than I ever thought I could. But all this goodness came at a price - it was all becoming too easy. More and more I was starting to feel that it wasn't me but the bike taking these crazy lines and speeding down these fast trails. Plus, I also learned that Israel is not BC, and Merav is not exactly Whistler. I spent way too much time pedaling up the trails on an 18KG bike that's specifically designed to do one thing: go fast downhill. I realized that on 80% of the time, this bike is not exactly the right tool for the job. Yes, it was fun, but it was also punishing. I hated the climbs, I hated missing out on epic rides with my friends, and I was quickly getting out of shape. Which takes us back to the beginning of my story, and today's ride with my friends.

So, in November of 2008 I bought a steel hard tail bike with 29" wheels and no gears, the Niner Bikes SIR9. In a way this took me back 15 years to my old steel Kona, but after a few rides with the SIR I've realized it's the best bike I've ever owned. I feel like all the improvements in bike technology over the years have made me numb. These long travel bikes are fun to ride, no doubt, but they isolate the rider from the terrain and from the sensations that come from being 100% connected with your bike. I now know that there's no such thing as a do-it-all bike, and that you need the right tool for the job to get the most out of it, but this bike IS the right tool for the job 85% of the time, it's all up to the rider to make it happen and not give up. I guess I went full circle from steel, rigid bikes to full-suspension aluminum beasts and back, and all I can say is steel is real baby, steel is real!

The Running Geek

2009-03-24T19:45:00.000+02:00

Aside from being a full time developer and a gadget fanatic I'm also an enthusiastic runner. Running helps me stay fit - that's obvious - but it also gives me an opportunity to expand my geeky horizons.

There are many aspects of running that can make a geek truly excited. You have your selection of motion control-super comfy-arch supporting-long lasting shoes, the dizzying array of light weight-sweat wicking-all weather-quick drying clothes, and of course the energy bars, gels, drinks and powders that fill up aisles and aisles in your local organic food co-op. But my two favorite running gadgets are, by far, the running watch and the music player. I'll start with the watch.

When I first started running I bought the cheapest stopwatch I could find in my neighborhood drug store. It cost me 10 bucks, and it worked perfectly. I ran the same 5k course twice a week, and all I really needed was to know how long it took each time.

After a while I decided I also wanted to track my heart rate. Many runners claim it makes training more efficient, but to me it wasn't about that. I just thought it was cool to be able to see your heart rate change in real time while running. So I went out and got the Nike C8 running watch with the HR monitor.

I enjoyed the C8 for a while, but there was a problem. It had no memory. It didn't keep a log of my runs, so I couldn't compare runs, track my progress or view my running history. All the data it displayed, disappeared as soon as I reset the timer, and that just didn't cut it. Oh, and there was one more issue. Over the years I started to run in more diverse locations. Tracking my running distance was becoming more important to me as well.

So I decided to spend the cash and buy the Polar RS200 with the accessory foot pod. This was a huge technological leap forward. The polar collected information about the time, distance, pace, heart rate, and more, showed it in real time, and - my favorite feature - allowed me to upload the data to the Polar Personal Trainer site for logging. I would sit for hours analyzing each run. I enjoying comparing recent runs with older ones, examining my progress. I generated reports showing the total distance I ran in the last year, and the aggregated number of calories I've burnt since I bought the watch. It was great. It was fun. But, you guessed it, there were some problems. First of all, the foot pod. The main issue was its accuracy. The foot pod could be very accurate as long as you calibrate it properly. And by properly I mean a different setting for each shoe, track and style of running. If you calibrated it for a road run, it would be off if you ran on a trail. If you calibrate it during your 18K slow pace run, it would be off in the 5K dash. Plus, it was bulky and inconvenient, and the batteries ran out just when I most needed it - in the middle of a race, of course.

Then there's Polar's "special" data transfer protocol. It goes like this: You place the watch close the your PC microphone and hit the send button (oh, and you have to make sure that the PC software is in listen mode first). At that point the watch starts emitting these horrible sounds just like an old 14,400 baud US Robotics modems sounded. About 50% of the time, the connection would fail mid-way through the transfer, and you'd have to start all over again.

These reasons, plus the unbelievably low price ($160 at Amazon) convinced me to purchase the coolest running watch (if you can even call it a watch) I ever had - the Garmin Forerunner 305. I'll never forget the first time I took it our for a run - it felt so good to loose the foot pod. Here's what I like about it: it's light weight yet feels very solid on the wrist. It has a large display that is very easy to read while running. It hooks up to the PC by USB, it even has its own little cradle. And it stores so much data about your runs it will knock your socks off. Since it has a GPS unit built right into the device, there's no foot pod, no external GPS, no calibration, and best of all, it works great during other outdoor activities like biking, skiing, or horse back riding (you can't swim with it though - it's not water proof).

Garmin offers a desktop client (Garmin Training Center) that lets you analyze your runs and store your training history. But I personally prefer the online options they offer. Garmin offers several online applications each for a different purpose or device. There's Training Peaks, New Leaf, Motion Based and the most recent addition to the Garmin web arsenal Garmin Connect. I currently use Motion Based which is decent - it provides plenty of information regarding the activity - but the UI is kind of old and confusing, and for some reason they charge $12 a month to view all your activities (with the free service gives you just see the last 10). Hopefully, it won't be long until they finally complete the migration to Garmin Connect.

Music players are the second piece of running gear I love to geek out on. Music goes exceptionally well with running (see Nike+). I love to run outdoors, and music helps me stay motivated and strong when I go out on long runs al by myself.

The first player I owned that's worth mentioning is the 3rd Gen iPod I got in late 2003. It had a 40GB hard disk - enough to store my entire music collection - but it was relatively big and uncomfortable to run with. I even bought an arm band for it, but it just didn't work well. After it got stolen, I bought a 60GB 4G Photo iPod, but again, it wasn't ideal for running. It often skipped, it was heavy, and not very resistant to hits and bangs. It died less than a year after I bought it.

That's when I bought my first running specific player - the Rio Forge. The Forge was small and curvy - designed to hold in your hand while running. It featured a built-in stopwatch, FM receiver and a memory card expansion slot. But it was terribly slow to start-up, the navigation controls were horrible to use while running, and the arm band was not comfortable at all.

Luckily I got a 1st Gen 1GB iPod Nano as a Christmas present from work. It was an amazing player. Tiny - compared to anything else at the time - slick, and real easy to use. Navigation was easy, start up was instantanious, music syncing was a breeze with iTunes, 1GB was just enough to store all my favorite running songs, and the Nano was small enough to hold in my hand while running. It's the player I used the longest so far.

Recently I gave up my Nano for a new player - the Sansa Clip 4GB. I was looking for a really tiny player that will clip on to my running shorts. I considered getting the iPod Shuffle, but the Sansa Clip turned out to be a much better deal. It cost about half of what a 2GB Shuffle would have cost me, it has a screen so I can see what's playing and choose a playlist, it has an FM tuner, a voice recorder, excellent sound quality, and comfortable in-ear headphones. I love the Clip - it's so small and light I barely notice it when I run.

So much for running geekyness. Next time I'll write about my other obsession - mountain biking.

Music Video Without Cameras

2008-10-02T19:00:00.006+03:00

While browsing Google's 10th birhtday site I ran across a cool video that cought my eye. It gave a behind the scenes look at the creation of Radiohead's "House of Cards" music video.

It turns out the entire video was shot without using a single camera or strobe. Instead, they used two experimental technologies, Geometric Informatics and Velodyne LIDAR that capture 3D models in real time. The former was used to create the close-up shots, while the latter was used for the landscapes.

Google also published a data viewer that lets you manipulate the 3D model to get a sense of the data captured, its properties, and size. The really cool part is that you can move Thom Yorke's head around while the video is playing! As a data visualization geek, this sort of stuff really gets me going.

Using Delegates to Implement APM

2008-09-01T18:30:00.007+03:00

In my previous post I described how delegates have evolved over the various versions of the .NET framework. In this post I want to elaborate and describe how to use delegates to implement asynchronous programming.

Many of today's PCs have multiple processors/cores in them, and there's a definite trend among processor makers to gradually increase that number in future models. In order to utilize the increasing number of cores, computer programs need to parallelize their execution, and assign processor intensive tasks to dedicated threads. Writing robust multi-threaded software is not easy. Threads need to be synchronized, data locked, and dead-locks are difficult to avoid. This increases the challenge for developers who need to write robust and efficient multi-threaded code.

To help programmers out, Microsoft introduced the Asynchronous Programming Model which simplifies multi-threaded programming. They have implemented it themselves in many classes throughout the .NET framework such as the FileStream, Socket, WebRequest, SqlCommand, etc. All of these classes offer asynchronous method calls along-side the standard synchronous versions. The async method name always starts with BeginXxx, and offers a corresponding EndXxx. For example, the SqlCommand class offers an ExecuteReader method, plus an async version of the method - BeginExecuteReader. To comply with the APM it also offers an EndExecuteReader method.

All delegates implement this pattern out-of-the-box. The all offer the standard Invoke method to execute the target method, and also offer the BeginInvoke and EndInvoke methods to execute the target method asynchronously.

This is the main reasons I love delegates so much.

Let's get down to it. One of the complexities of multi-threaded programming is figuring out when an async process completed its work. This is where the APM offers a great deal of help. There are three techniques to find out when a BeginInvoke is done: wait, poll and callback. I'll use a sample to describe the three techniques.

class PrimeCalc
{
 public int GetNextPrime(int num)
 {
    int p = num + 1;
    while(true)
    {
        if(IsPrime(p))
        {
             break;
        }
        p++;
    }
    return p;
 }
}

The PrimeCalc class has a GetNextPrime method that calculates the next prime number after the number passed in to the method. The class uses some internal methods to do the calculation (I'll add the entire source code at the end of the post) and returns the next prime number it finds. We'll use this method to simulate a compute-intensive task.

Since our target method takes an int as a parameter and returns an int as a return value, we could use the Func< as our delegate:

PrimeCalc calc = new PrimeCalc();
Func<int, int> del = calc.GetNextPrime;

Wait Until Completed Technique

public void WaitUntilComplete(int num)
{
   PrimeCalc calc = new PrimeCalc();
   Func<int, int> del = calc.GetNextPrime;
   IAsyncResult result = del.BeginInvoke(num, null, null);

   // Do some other work here

   // Suspend this thread until the async operation completes
   int prime = del.EndInvoke(result);
}

This is not a very efficient way of using the APM. If the compute-intensive task takes longer than the "other" work that is being done in the mean time, the thread will be suspended and wait for the delegate to return.

Polling Technique

public void Poll(int num)
{
   PrimeCalc calc = new PrimeCalc();
   Func<int, int> del = calc.GetNextPrime;
   IAsyncResult result = del.BeginInvoke(num, null, null);

   while (!result.IsCompleted)
   {
       // Do some other work here
   }

   // Get the result from the async operation
   int prime = del.EndInvoke(result);
}

This option is also not very efficient because the while loop that runs until the async operation completes would consumes CPU resources even after the "other" work that needs to be done is complete.

Callback Technique

This is by far my favorite rendezvous technique of all, it is a bit more complex to implement, but offers greater flexibility and control, and is more efficient in terms of resource management.

public void Callback(int num)
{
   DateTime start = DateTime.Now;
   Console.WriteLine("Starting async calculation at: {0}", start);

   PrimeCalc calc = new PrimeCalc();
   Func<int, int> del = calc.GetNextPrime;
   del.BeginInvoke(num, CalcCompleted, start);
}

private void CalcCompleted(IAsyncResult result)
{
   DateTime start = (DateTime)result.AsyncState;

   Func<int, int> del = (Func<int, int>)((AsyncResult)result).AsyncDelegate;
   int prime = del.EndInvoke(result);

   DateTime end = DateTime.Now;
   TimeSpan length = end.Subtract(start);
   Console.WriteLine("Completed async calculation at: {0}", end);
   Console.WriteLine("Async calculation took {0:F} seconds.", length.TotalSeconds);
}

The basic idea here is that the delegate calls the callback method when it completes. The signature of the callback method should match the AsyncCallback delegate signature:

private void CalcCompleted(IAsyncResult result)

This time, when we call the BeginInvoke method on our delegate, we pass in the callback method as the second parameter, and the third parameter could be any state object we would like to pass in to the EndInvoke method. In this sample I passed in the start DateTime of the async opertaion.

In the callback method you should get a reference to the delegate instance (by casting the result param to the appropriate type), and use it to call EndInvoke. It is important to call EndInvoke even if your method does not return a value. This prevents reasource leaks.

You get a reference to the state object you passed in the BeginInvoke 3rd parameter by casting the result's AsyncState property to the appropriate type.

Here is the entire PrimeCalc class source code:


namespace AsyncProgrammingModel
{
class PrimeCalc
{
 private List<int> primes;

 public PrimeCalc()
 {
  primes = new ListList<int>();
  primes.Add(2);
  primes.Add(3);
 }

 public int GetNextPrime(int num)
 {
 
  int p = num + 1;
  while (true)
  {
   // Create a list of all prime numbers up to p.
   AddPrimesToList(p);
   if (IsPrime(p))
   {
    break;
   }
   p++;
  }
  return p;
 }

 private void AddPrimesToList(int numberToTest)
 {
  int n = primes[primes.Count - 1] + 2;
  while (n < numberToTest)
  {
   if (IsPrime(n))
   {
    primes.Add(n);
   }

   // Skip even numbers.
   n += 2;
  }
 }

 private bool IsPrime(int n)
 {
  bool foundDivisor = false;
  bool exceedsSquareRoot = false;

  int i = 0;
  int divisor = 0;

  // Stop the search if:
  //     there are no more primes in the list,
  //     there is a divisor of n in the list, or
  //     there is a prime that is larger than the square root of n.
  while ((i < primes.Count) && !foundDivisor && !exceedsSquareRoot)
  {
   // The divisor variable will be the smallest
   // prime number not yet tried.
   divisor = primes[i++];

   // Determine whether the divisor is greater than the square root of n.
   if (divisor * divisor > n)
   {
    exceedsSquareRoot = true;
   }
   // Determine whether the divisor is a factor of n.
   else if (n % divisor == 0)
   {
    foundDivisor = true;
   }
  }

  return !foundDivisor;
 }
}
}

The APM, Anonymous Methods and Lambda Expressions

2008-09-03T19:30:00.003+03:00

In this post I would like to continue from where I left of in my previous post about the Asynchronous Programming Model, and show how the APM could be more concise using Anonymous Methods and Lambda Expressions.

Using "classic" delegates the code to implement the APM looks like this (as shown in greater details in my previous post):

public void ClassicAsync(int num)
{
 DateTime start = DateTime.Now;
 Console.WriteLine("Starting async calculation at: {0}", start);

 PrimeCalc calc = new PrimeCalc();
 Func<int, int> del = calc.GetNextPrime;
 del.BeginInvoke(num, CalcCompleted, start);
}

private void CalcCompleted(IAsyncResult result)
{
 DateTime start = (DateTime)result.AsyncState;

 Func<int, int> del = (Func<int, int>)((AsyncResult)result).AsyncDelegate;
 int prime = del.EndInvoke(result);

 DateTime end = DateTime.Now;
 TimeSpan length = end.Subtract(start);
 Console.WriteLine("Completed async calculation at: {0}", end);
 Console.WriteLine("Async calculation took {0:F} seconds.", length.TotalSeconds);
}

With an anonymous method we can write the callback method inline like this:

public void AnonymousAsync(int num)
{
 DateTime start = DateTime.Now;
 Console.WriteLine("Starting anonymous async calculation at: {0}", start);

 PrimeCalc calc = new PrimeCalc();
 Func<int, int> del = calc.GetNextPrime;

 del.BeginInvoke(num, delegate(IAsyncResult result)
 {
     int prime = del.EndInvoke(result);
     Console.WriteLine(prime);

     DateTime end = DateTime.Now;
     TimeSpan length = end.Subtract(start);
     Console.WriteLine("Completed anonymous async calculation at: {0}", end);
     Console.WriteLine("Async calculation took {0:F} seconds.", length.TotalSeconds);
 }, null);
}

And, finally, using a lambda expression the implementation is even more concise:

public void LambdaAsync(int num)
{
 DateTime start = DateTime.Now;
 Console.WriteLine("Starting lambda async calculation at: {0}", start);

 PrimeCalc calc = new PrimeCalc();
 Func<int, int> del = calc.GetNextPrime;
 del.BeginInvoke(num, result =>
 {
     int prime = del.EndInvoke(result);
     Console.WriteLine(prime);

     DateTime end = DateTime.Now;
     TimeSpan length = end.Subtract(start);
     Console.WriteLine("Completed lambda async calculation at: {0}", end);
     Console.WriteLine("Async calculation took {0:F} seconds.", length.TotalSeconds);
 }, null);
}

Microsoft Thinks Different

2008-09-06T10:00:00.001+03:00

I just saw the first Microsoft Windows ad featuring Bill Gates and Jerry Seinfeld. This ad campaign is Microsoft's answer to Apple's Mac vs. PC ads which have been going unchallenged for over two years.

I don't know if the ad is working or not, it's probably too soon to tell, but it's definitely been a long while since a Microsoft ad campaign made such a buzz. There is a lot of talk about it in the blogosphere and even in mainstream media.

According to the Wall Street Journal, Microsoft is spending $300M on this ad campaign (Jerry's cut is $10M), so it better work. After the annoying and the what-are-you-trying-to-prove? that-everyone-thinks-Vista-sucks! campaign a.k.a. "Mojave Experiment" the expectations are running high.

It's ironic that when you search for "Seinfeld ad" in YouTube, the first result is a Mac ad :-)

The Evolution of Delegates

2008-08-29T14:00:00.004+03:00

In this post I'll discuss how delegates have evolved along with the evolution of .NET and C#. Specifically, how the introduction of anonymous methods and lambda expression helped make delegates more concise and useful.

This post is the first in a series of "Back-to-Basic" posts where I'll discuss basic .NET concepts and show how they have progressed with each new release of the .NET Framework.

I love delegates. If I had to come up with a list of my top 5 .NET features, delegates would definitely be high up on the list.

A Delegate, as defined by MSDN is:

"A type that defines a method signature, and can be associated with any method with a compatible signature. You can invoke (or call) the method through the delegate. Delegates are used to pass methods as arguments to other methods."

Delegates are first class citizens in the .NET framework and the C# language, and one of the fundamental types in the framework. They are used throughout the framework and enable important features such as events and asynchronous method calls.

In the old days, if we wanted a delegate that takes one parameter and returns void we had to declare one like this:

public delegate void DoWorkDelegate(string data);

Then we had to implement a method that conforms to the signature of the delegate:

private void DoSomeWork(string s)
{
 // Do some work here
 Console.WriteLine(s);
}

And finally, instantiate the delegate in our code:

DoWorkDelegate del = new DoWorkDelegate(DoSomeWork);

In .NET 2.0 we could use a simplified syntax to instantiate the delegate:

DoWorkDelegate del = DoSomeWork;

The introduction of Generics in .NET 2.0 introduces a generic delegate Action. Action encapsulates a delegate that returns void and accepts 0 to 4 parameters (there are actually 5 generic Action types defined: Action, Action<T>, Action<T1, T2>, Action<T1, T2, T3>, Action<T1, T2, T3, T4>). So in the above example, we could have saved us the trouble of defining our own custom delegate "DoWorkDelegate" and instead used this:

Action<string> del = DoSomeWork;

.NET 2.0 also introduced the concept of Anonymous Methods. This lets us avoid defining the "DoSomeWrok" method altogether and write it inline with the definition of the delegate:

Action<string> del = delegate(string s)
{
 Console.WriteLine(s);
};

Finally, C# 3.0 introduced Lambda Expressions, which allow us to define the method inline like this:

Action<string> del = s =>
{
 Console.WriteLine(s);
};

One more delegate worth mentioning is the Func delegate. Func was introduced in .NET 3.5 and just like its older brother, the Action, it encapsulates a delegate, but unlike Action Func encapsulates a delegate that takes 0 to 4 and returns a value. For example:

// Using Func we can replace this:
delegate int DoWorkDelegate(string data);

// with this:
Func<string, int> del;

In all the above samples (except for the last one) we end up with a "del" object. We could then use the "del" instance anywhere in our code to execute the "DoSomeWork" method. We could even pass "del" as an argument to other methods or objects that could also execute the same method:

// This is the verbose way:
del.Invoke("Do some work");

// This is a bit more concise
del("Do some work");

// This executes the method asynchronously
del.BeginInvoke("Do some work", null, null);

Next time on SapienCoder I will describe how to use delegates to implement Asynchronous programming patterns.

Will reCAPTCHA Save Humanity?

2008-08-26T20:00:00.002+03:00

Probably not, but it will make us more productive during the tedious process of proving our humanhood to some random web server.

Anyone who's using the internet these days for anything more involved than reading news knows those annoying sets of garbled characters that appear at the end of checkout and registration pages.

Those are called CAPTCHAs (an acronym for "completely automated public Turing test to tell computers and humans apart") and they are designed to test that we, the users of the web site are in fact human. Now, I don't disagree with the motivation behind CAPTCHAs. Today's Web is infested with crawling bots and other malicious agents running around causing all kinds of mayhem. But, it just seems like a terrible waste of time for something that aught to be straight forward (how many times have you mistyped a CAPTCHA and had to enter it over and over again until the server acknowledged your humanhood?).

Luis von Ahn, the inventor of the CAPTCHA, said in an interview recently that by his estimates people spend an average of 10 seconds solving one of those CAPTCHA puzzles. Multiply that by the number of CAPTCHAs solved daily (aprox. 200 million) and you come to the staggering number of approximately 500,000 hours per day world wide. Astonishing when you think about it in these terms.

That's exactly why he came up with the brilliant idea of the reCAPTCHA.

There is a growing number of libraries and archives who are working on digitizing their entire collections. The process involves scanning the printed document (book, newspaper, magazine, historical document, etc.) to an image file, and then running a software called OCR (for Optical Character Recognition) that tries to recognize the words in the scanned image and turns them into a searchable text document. It turns out that the OCR software can't "read" every document with 100% accuracy. That's where the power of crowd-sourcing comes in. ReCAPTCHA uses the words that computers can't decipher with OCR software (therefore can't be "read" by malicious robots) and displays them to humans. Each reCAPTCHA actually consists of two words, one was successfully recognized by the computer and the other wasn't. Each image is also shown to several people to verify the accuracy of the translation. If they agree on the translation the transcription is considered accurate and will be added to the text it originally came from. Currently more than 40,000 web sites world wide are using reCAPTCHA technology including some you might have heard of like Ticketmaster, Facebook and CraigsList. There are plug-ins for WordPress, Joomla, Drupal and many other popular web applications, as well as APIs for PHP, ASP.NET, Java, Perl, Ruby etc. The implementation is simple and there are lots of resources available for site developers.

Next time you run into those squiggly characters when commenting on a blog, or signing up for an online email account, make sure your time is not wasted on a standard CAPTCHA text. Let the site owners know your time could be spent on saving humanity, or at least it's written word.

The Olympics on Your PC

2008-08-07T19:45:00.000+03:00

When the Olympic flame is fired up in Beijing tomorrow, and the Games begin, many people will realize that they can't watch their favorite athlete or event because of the time zone difference with China. Well this year is the first time ever that most of the events will also be available in high quality HD directly on your PC at any time you like (yes, even at work when your boss is not looking).

NBC had partnered with Microsoft to deliver the 2008 Beijing Summer Games over the internet. At first NBC considered going with Adobe Flash which is considered the industry standard for Web video, but Microsoft was able to convince NBC that their Silverlight technology will deliver better quality to the end user. They plan on streaming most of the events live, and also make them available as on-demand content for your viewing pleasure any time you like.

Thanks to Silverlight, NBC can offer a unique viewing experience not even available on high end TVs. For example, they will offer a picture-in-picture view of two simultaneous events, and, for the real sports junkies, a "control room" mode with four events streaming side by side on the screen.

I can't imagine the complexity involved in delivering such a massive amount of data to so many users in real-time. This drawing (taken form an interesting News.com article) tries to explain it:

It is interesting to see how this "experiment" turns out, and if the masses are ready for Web TV (and if the technology stack is there too).

Don't forget to check out the NBC Beijing 2008 site at NBC Olympics.

StackOverflow Private Beta

2008-08-05T20:18:00.003+03:00

I'm happy to announce that as of this morning I'm an official beta tester for the all new programmers Q&A site StackOverflow.

StackOverflow is the brainchild of Jeff Atwood and Joel Spolsky who have decided to create a new knowledge transfer site specifically for programmers (Knol for programmers if you will). The service is totally free and is designed both functionally and graphically in the spirit of Web 2.0 (and, yes, there's also a podcast).

Each question submitted to StackOverflow is tagged by topic. Users can then answer the question, vote on it (in a very Digg like way), add their own answer and vote on the existing answer. The idea is that by using this democratic process the most relevant/accurate/knowledgeable answers will rise to the top.

Users are rewarded for their participation with different badges that are added to their profile. Badges include Guru, Specialist, Teacher, Student and many more. The bagdes act as incentives that are supposed to encourage users to participate.

So far, the site looks very good. The volume is suprisingly high for the first day of the private beta (with only about 500 users), and the concept seems promising. We'll see how it unfolds.

Update: To apply for the beta, click here.

Microsoft Sphere

2008-07-31T09:29:00.002+03:00

There's been lots of rumors lately about a cool new spherical Surface computer.

The original Surface is a multi-touch table-top PC designed mainly for commercial use in bars and restaurants. It's really too early to tell how it will be used, and the potential is enormous, but for now this is how it is conceived:

Last week Microsoft unveiled the Sphere during their annual Research Faculty Summit in Redmond. It's an amazing device that seems to be geared towards interactive exhibits in science museums, but again, only time will tell what the true killer app for the Sphere will be.
Here's a link to a Gizmodo hands-on:
http://gizmodo.com/5030603/hands-on-with-the-microsoft-surface-sphere-prototype

And a YouTube video:

Claiming My Blog

2008-07-30T10:39:00.001+03:00

Technorati wants me to claim my blog for them, so here goes:

Technorati Profile

Lets release the spiders and see what happens...

Merging Flickr Accounts

2008-07-28T18:30:00.001+03:00

How to Use the FlickrNet API to Merge Flickr Accounts

A few months ago, my wife finally convinced me that it doesn't make any sense to manage two separate pro Flickr accounts, and that we should transfer all the photos to one account and drop the other.

So, I looked online for tools that merge Flickr accounts, and couldn't find any. Not even on CodePlex. Don't get me wrong, I found a gazzillion mass downloaders, and uploaders and a bunch of other very cool stuff. But not a merge tool. I even contacted Flickr support, but they were totally useless.

What I really wanted was a way to download the photos from the source account, and keep all the metadata I have meticulously added to the photos over the years - titles, descriptions, sets, tags, geo tags, etc. Then, upload to the target account without disrupting the flow on my photostream. I didn't want a bunch of old photos clogging it up.

Being a developer, I decided to write my own Flickr app using the FlickrNet API library, which turned out to be fun and quite enjoyable.

I don't want to bore you with all the details of my implementation. I'd just like to point out some interesting aspects and potential pitfalls.

Getting an API Key

To get started, you'll need an API key from Flickr. Go to the Services page and click on the "Apply for an API Key" link.

The FlickrNet Library

Download the FlickrNet library from CodePlex. You can download the binaries and reference the DLL from your code. I opted for the more geeky option, and downloaded the source code, and added the FlickrNet project to my solution. This way I could step through the code and better understand how it works.

Authorizing

If you want your app to do more than merely download public photos, your users will need to authorize it. The process is quite simple, but not that obvious. You need to launch a web browser and navigate to a Url. Here's what you do to get the Url.

FlickrNet.Flickr flickr = new FlickrNet.Flickr(ApiKey, SharedSecret);
string frob = flickr.AuthGetFrob();
string url = flickr.AuthCalcUrl(frob, FlickrNet.AuthLevel.Write);

AuthLevel can be one of the following values:

Read
Write
Delete
None

Once you have the Url, launch the default web browser.

System.Diagnostics.Process.Start(url);

At this point, the user needs to login to her account and authorize the application. Now you can retrieve the authorization token from Flickr.

FlickrNet.Flickr flickr = new FlickrNet.Flickr(ApiKey, SharedSecret);
FlickrNet.Auth auth = flickr.AuthGetToken(frob);
string token = auth.Token;
string userName = auth.User.Username;

Downloading Photos Metadata

This is a relatively simple process. Use the PhotoSearchOptions object to define the photos you are interested in (this could be based on a user, tag, etc.). The PhotosSearch method doesn't return all the photos it finds in one call, rather it returns "pages" of photos. You use the same PhotoSearchOptions to move to the next page and bring the next batch of results.

// Get the user Id based on the user name
FlickrNet.Flickr flickr = new FlickrNet.Flickr(ApiKey, SharedSecret);
FlickrNet.FoundUser user = flickr.PeopleFindByUsername(UserName);
string userId = user.UserId;

// Create a PhotoSearchOptions object
FlickrNet.PhotoSearchOptions options = new FlickrNet.PhotoSearchOptions();
options.UserId = userId;

// Retrieve the user's photos
FlickrNet.Photos photos = flickr.PhotosSearch(options);

Downloading Sets Metadata

// Get all the photosets for the user
FlickrNet.Photosets sets = flickr.PhotosetsGetList(userId);

Linking Photos to Photosets

This is where it gets a little tricky. See, Flickr allows photos to belong to 0-n sets. So, in theory I had to account for photos that are not part of any set, photos that belong to a single set, and for photos that belong to multiple sets. Since almost all of my photos belong to just one set, I've decided to cut myself some slack, and only deal with 0-1 sets per photo.

foreach (FlickrNet.Photoset set in sets.PhotosetCollection)
{
 ...
 ... //Save photoset metadata
 ...

 // Get the photoset's photos
 FlickrNet.Photoset set1 = flickr.PhotosetsGetPhotos(set.PhotosetId);
 FlickrNet.Photo[] setPhotos = set1.PhotoCollection;
 foreach (FlickrNet.Photo photo in setPhotos)
 {
  ...
  ... // Link photo to photoset
  ...
 }
}

Downloading Photos

The one thing to keep in mind here is that Flickr stores multiple versions of each photo (with different resolutions), so you want to make sure you download the largest one.

FlickrNet.Sizes sizes = flickr.PhotosGetSizes(photo.PhotoId);
FlickrNet.Size size = sizes.SizeCollection[sizes.SizeCollection.Length - 1];
string sourceUrl = size.Source;
string fileName = size.Source.Substring(size.Source.LastIndexOf("/") + 1);

WebClient client = new WebClient();
client.DownloadFile(sourceUrl, fileName);

Uploading Photos

Uploading the photos is easy. I just had to change the dates on the photo after the upload to make sure it shows up in the correct place in my photostream based on the upload date, and add the GEO tags, if they existed in the original metadata.

FlickrNet.Flickr flickr = new FlickrNet.Flickr(ApiKey, SharedSecret, AuthToken);
string photoId = flickr.UploadPicture(fileName, title, description, tags, true, false, false);
flickr.PhotosSetDates(photoId, datePosted, dateTaken, FlickrNet.DateGranularity.FullDate);
flickr.PhotosGeoSetLocation(photoId, latitude, longitude);

Creating Photosets

Creating a Photoset is a breeze. Just remember to assign a primary photo to the set, and make sure the photo id is the new photo id (from the target account) not the old one.

FlickrNet.Flickr flickr = new FlickrNet.Flickr(ApiKey, SharedSecret, AuthToken);
FlickrNet.Photoset set = flickr.PhotosetsCreate(title, description, primaryPhotoId);

Now you can add the photos (already uploaded) to the newly created set.

flickr.PhotosetsAddPhoto(photosetId, photoId);

Conclusion

Working with the FlickrNet API is both easy and fun. I'm personally happy I've decided to write my own app, I think I've learned a lot from it. If you are like me, and believe that reading code makes you a better developer, I recommend downloading the source code version and using is in your solution.

A New Beginning

2008-07-14T13:00:00.029+03:00

New beginnings are hard. Starting something new - a new job, start-up, or even a blog - is not a simple task. It takes effort. It's against our nature, really. Newton, with his first law of motion explains it well (I'm paraphrasing):

"An object at rest tends to stay at rest and an object in motion tends to stay in motion with the same speed and in the same direction..."

We are conditioned to do what we know, what we're good at. Stay the course. Most of us are afraid of change, of the unknown. It's natural.

But Newton realized that things are not that simple, so he added:

"unless acted upon by an external, unbalanced force."

Several weeks ago I started a new job as a developer at SAP Labs in Israel (a definite "unbalanced force"). This new job involves quite a bit of research around the latest Microsoft technologies (WCF, WPF, MOSS, OBA, VSTO, etc.). So I figured, I might as well share my experiences with other developers in the community, and what better way than an online blog.

With everything I have to learn these days (a new company, a new product, new technologies) I know I'll be drinking from the fire hose for a while, but I honestly believe that writing will actually help me make sense and keep track of it all.

So, hang on, and enjoy the ride.