.entrypoint

Towards the end of the last year I had bragged about some new year resolutions. One of them was that I would be posting more frequently here. Well it has been about 2.5 months since my last post.  Not good going. The status of the rest of the resolutions are very similar, if not worse. I am taking solace in that it seems to be a universal problem

One of the reasons of me not being able to keep with any of things that I wanted to do was my illness. I have been having a series of throat infections starting from mid December of last year. After the first infection subsided I got an even worse condition known as peritonsillar abscess (PTA), which is much rare compared to tonsillitis but far more painful and serious. The condition consists of infection on the backside of the tonsils which forms an abscess which is filled with puss. If not treated, there is a chance that it might even lead to death. I was put on antibiotics which did not help. So the doctor gave me steroids and stronger antibiotics which seemed to work. But I got another infection as soon as the current infection subsided. This time even antibiotics and steroids weren’t helping. So the doctor had to make a small cut into the throat and drain the puss. It was extremely painful and I almost fainted. I think it was the incompetence of the doctor that caused most of the pain. To top it all, when I was standing dazed from all the pain and blood oozing down my mouth, he was trying to persuade me to do a tonsillectomy as soon as possible. I wanted to kick his balls so hard that he would spit them out.

I decided to switch doctors and I really have to thank God that I found a very good doctor (Dr. Sunil Ummat from Northwest Face in Kirkland). He had to do another draining but this time the it was almost painless. This is one of the times where I recognized the importance of seeing a good doctor, I swear that the difference is like night and day. The problem with peritonsillar abscess is that once you get a PTA, the structure of your tonsils have forever changed – they are never the same again. There is a good chance that you can another abscess and there is no way to prevent it other than staying healthy and making sure you don’t get a throat infection. That is like trying to prevent a common cold. You can only do so much. Many doctors suggest a wait and see approach while others recommend a tonsillectomy. Usually it is up to the patient to make the decision and Dr.Ummat did the same. I was not sure. I did not want to go through a PTA again but I was quite afraid of doing a surgery. Dr. Ummat was very patient and explained all the pro and cons to me. After a couple of weeks of deliberation I decided to do the tonsillectomy. I had it done last thursday. Today is the 8th day after the surgery and I am doing pretty well now. I haven’t fully recovered yet, but the pain is mostly gone (I am still on pain medication though) and I have started eating soft foods. Cant talk much either. One of the (positive) side effects of  the surgery is that I lost 14 pounds in less than a week

I am not making any more promises now about frequent blogging and reading books and learning technologies. I am going to take life as it comes because if there is one thing that I have learned so far from 31 years of life it is that you can’t really expect life to go the way you want it to (that is not to say that I am not in a bad position today, but I have had so many deviations from where I expected to go in life). I am starting the see the value of the Zen approach of going with the flow and taking it easy and enjoying life while I can.

These thought are not caused by the bitter experience of my recent illness or because I believe I have achieved enlightenment but these are thoughts that have been shaping up for several years now. I have been reading a book called Power of Less recently and I very much like the idea of minimalism. I have hundreds of books. More than I can read in my lifetime, but I just keep on buying more. Now I think what I love is not the books, but the experience of buying them. Just the way women love to shop for clothes. I used to scour over Amazon for several hours a day for books that I don’t have, all the while having on my shelf several hundred books that are in the “must read” category. Now that I have identified a problem, I have decided to fix it buy not buying more books but by reading the books that I already bought. I think that having a few good things and enjoying them is far better than having lots of good things but never being able to enjoy them. I have decided to experience less number of things but to experience each more deeply. Let us see how it goes.

I had written a post on Functions in F# a couple of days ago and Binil posted a comment which prompted me to post a follow up to add some information that I left out in the original post.

F# Syntax

F# has two syntax forms available – a lightweight syntax and a verbose syntax. The lightweight syntax uses indentation to mark the beginning and end of code blocks. This naturally results in more concise code. The verbose syntax uses additional keywords to demarcate code blocks making the code lengthier than it needs to be but it makes the code less sensitive to indentation (imagine copy-pasting and sending code in email etc).

The lightweight syntax is on by default. You can explicitly set it to on by using

#light

The verbose syntax is always on which means you can still use the verbose keywords even if the lightweight syntax is on.  We can enforce the verbose syntax by switching off the lightweight syntax as follows

#light “off”

The lightweight syntax is in more prominent use than the verbose syntax and it seems that going forward the verbose syntax might be obsolete.

Only spaces can be used for indentation in F#, TABs are not accepted. Visual Studio by default converts TABs to spaces. This can be set in Tools –> Options dialog under Text Editor –> F# –> Tabs.

Tail Recursion

I had mentioned about recursive functions in my previous post on Functions in F# but I did not mention anything about tail recursion. Given the importance of recursion in F#, this is a very important topic and I want to thank Binil for bringing it to my notice.

First, let me provide some background info on what is bad about recursive functions and why tail recursion is the preferred way to write recursive functions.

When is function needs to be executed, a block of memory is allocated on the system stack for the function and is called a stack frame. When the function completes execution, this memory is reclaimed and is called unwinding the stack.

Recursive functions call themselves repeatedly until an exit condition is met. This means that a new stack frame has to be created each time the recursive call is made. Given enough nested function calls there wouldn’t be any more space on the system stack and would cause an undesirable condition called stack overflow. The program execution is terminated forcefully by the runtime.

If the function calls are not recursive, for example calling a function 1000 times in a for loop, the memory block for a function can be reclaimed when the function execution is over. So what we need to try to achieve is to write the function in such a way that the stack frame of the calling function need not be maintained while execution proceeds to the next function call. The way to do this is to make the recursive call as the last statement in the function. When we do that the compiler produces different code which allows the stack frame of the calling function to be unwound and the memory reclaimed, in effect making it similar to calling the function in a loop. This technique is called tail recursion.

Let us look at some code to make this more clear. Here is the recursive implementation of factorial that I wrote in my previous blog post.

let rec factorial x=
    if x <= 1 then
        1
    else
        x * factorial (x-1)

Here it might look as if the recursive call is the last statement in the function, but it is not. It would become clear if we wrote it this way:

let rec factorial x=
    if x <= 1 then
        1
    else
        let product = x * factorial (x-1)
        product

Now it becomes clear that the last statement in the function is returning the value of product. We also see that the function has to maintain the value of x in its stack frame and multiply it with the value returned by the recursive call. So if the function is written as shown above, there is no way to reclaim the stack memory until the chain of recursive calls return. So let us re-write the function in using tail recursion.

let factorial x =
    let rec tailRecFactorial x prod =
        if x <= 1 then
            prod
        else
            tailRecFactorial (x-1) (prod * x)
    tailRecFactorial x 1

Here we have a nested function which takes the product up to the current stage as a parameter which means nothing needs to be stored on the stack of the calling function. The stack frame can be safely reclaimed. The compiler is able to spot the tail recursive calls and generates code as if the function was called in a loop. Execution returns the original calling point when the exit condition is met.

The method I showed above to achieve tail recursion is called accumulator pattern. Another way is to use Continuations.

Trivia

When I was writing the non tail recursive factorial function, by mistake I wrote it this way:

let rec factorial x =
    if x <= 1 then
        1
    else
    x * (factorial x-1)

Can you spot the problem ?

Hint: It causes a StackOverflowException when executed.

As I have posted here, I have made some resolutions for the new year. If nothing, just for the fun. I have to add two more things to the list.

• Learning F# and
• Reducing my weight.

I have been trying to learn F# for over a year now (maybe even a little more). I have all the F# books in print now as well as the PDF for the upcoming Manning MEAP – Functional Programming for the Real World. But they been collecting dust on my shelf. Functional programming requires a new mindset and hence requires a little more effort for me than studying a new imperative language. The first book that I bought is Expert F# which is definitely the wrong book for a beginner. It is written by Don Syme et.al. who is the primary designer of the language and is a little dense. It is a good book with a lot of information but it is just not good for somebody new to functional programming. Once you have grasped the main ideas behind functional programming, it is a good book to have. The second edition of this book is coming up soon.

The game changer for me was Programming F# by Chris Smith which, IMHO, is the best book out there today to learn F#. It is a surprisingly small book and is written with such clarity that even somebody with absolutely no exposure to functional programming languages would be able to learn from it. It makes the ideas accessible and has some brilliant examples to showcase some of the features of F#. It kind of feels like an easy-going friend, which is exactly what you need when exploring unfamiliar grounds. I was so impressed with the book that I wrote a review of the book on Amazon giving it 5 stars.

I am not entirely comfortable with F# yet. But I have my feet wet and I plan to make the plunge in 2010.

Another thing that I want to tackle in 2010 is my weight (and fat). I am 190 lbs now. I used to be something like 175 lbs 3 years ago when I came to USA. 15 lbs in 3 years ! I am definitely worried about this. So is my wife. I had taken diets a couple of times previously and had always managed to reduce weight. But it always came back with a vengeance. So I am not sure whether another diet is the solution. Being on a diet is one of the most worst experiences that I have been through. Food is always on your mind and you can’t eat it. You are constantly fighting the sugar craving (I was on a low-carb diet). It is hell.

Although I haven’t made any specific plans, I think I would concentrate more on exercise and less on diet this time. Let us see how it goes.

Happy Holidays !

Wikipedia says that

…functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions…

The point I wish to make here is that functions are the  most important “things” in a functional programming language. You can say that functions are “first class citizens” in a functional programming language. This means that functions can be passed around as parameters and return values of other functions, just like any other data. Functions which can take other functions as parameters and/or return values are called Higher-Order Functions.

Functions and Type Inference

Here is an example of a simple function in F#.

let triple x = 3 * x

Here triple is the name of the function and x is the name of the parameter passed to the function. Contrary to C# naming convention for function, F# uses camel casing. Even though we have not specified any type information, the compiler is able to infer that this function takes an integer as parameter and returns an integer. This is called Type Inference and makes your F# program more concise.

How did I know that the compiler inferred the parameter and return value as int? I typed in the above functional declaration in F# interactive and terminated it with ;; and hit Enter. F# showed me:

val triple : int –> int

This means that triple is a function which takes an integer as parameter and returns an integer. If we try to call the function with a float as parameter

triple 3.0

it will spit out an error message as follows.

stdin(4,8): error FS0001: This expression was expected to have type
    int   
but here has type
    float   

We know that * (multiplication operator) works with floats as well, so why this error ? The reason for this is that in the absence of any additional type information the compiler simply defaulted the type to integer. So triple is a function which can take an integer as parameter and return an integer which is equal to three times its input. It is equivalent to the following C# function.

static int Triple(int x)
{
      return 3 * x;
}

Since the function expects integer, a parameter of type float will produce an error.

So what do we do when we need a datatype other than the default type that the compiler is able to infer? We give a hint to the compiler via type annotation.

let triple (x: float) = 3.0f * x

Note: In the above example type annotation is not strictly required because the compiler would infer x as float because 3.0f is float. But it does show you how to annotate a function parameter with its type.

Higher Order Functions

The functions mentioned above are not a higher-order functions because they do not take a function as parameter, neither do they return one. List.map and List.filter are examples of higher order functions. List.map takes a function and applies it to each item in the list (also passed as parameter to it) and returns a new list with the output values. List.filter takes a function and list as parameters and returns a new list. The output list contains those values from the input list for which the input function returned true. An example is shown below which makes use of both these higher order functions.

let triple x =
    3 * x

let isEven x =
    x % 2 = 0

let actOnEven action numbers=
    List.map action (List.filter isEven numbers)

[<EntryPoint>]
let main(args:string[]) =
    let results = (actOnEven triple [1 .. 10])
    Console.WriteLine (results)
    0

Here actOnEven is itself a higher order function.

Recursive Functions

Recursive functions are functions that call themselves. An important tenet of functional programming is the use of recursion instead of looping. We can create recursive functions using the following syntax.

let rec factorial num =
    if( num <= 1) then
        1
    else
        num * factorial (num - 1)

The rec keyword is a helping hand to the compiler for type inference. Personally, I don’t like it but I think they couldn’t find a way around it.

Function Currying

Currying (named after Haskell Brooks Curry) is an interesting technique in which you pass one of the arguments to a function and it returns another function which takes the rest of the arguments. For eg., consider the function

let add x y = x + y

If you run this in F# interactive, you will see the following message:

val add : int -> int –> int

This means that add is a function which takes an integer and returns a function which takes another integer as parameter and returns an integer. So if we call add with just one parameter, it will return another function which takes the second parameter.

let addToTwo = (add 2)

To be clear, addToTwo is a function that takes one integer parameter and returns an integer.

For eg,

addToTwo 8

will return 10.

Here addToTwo is the curried function and this technique is called function currying. Although this may look like a strange and useless language feature, it has interesting and powerful applications in functional programming (like the pipe forward operator). I will write more about this in future blog posts.

Nested Functions

In F#, a function can contain another function. Here is a simple example.

let printList numbers=
    let print num=
        printfn "%i" num
    List.map print numbers

Here print is a function nested in printList.

Some of the feature that I have mentioned here would be new to C# programmers and might feel a little strange. But have hope, for all will become more clear with time. We need to see some solid examples to appreciate the power of some of them. I have mostly presented useless examples but I hope a reader would have gleaned atleast a little information about functions and its usage in F# from this post. There is more to write but it is getting late (3 am) and tomorrow is a working day, so I gotta go. Will be back with more on F#.

References:

Programming F#

Expert F#

If you took the shortcut of a Visual Studio Setup project (as opposed to using Wix) then you must have faced the same problem that I did, viz., not being able to create the MSI as part of your TFS nightly builds which hands over the bits to the test team. The problem here is that the vdproj files of the setup projects is in a format that MSBuild (and TeamBuild) does not understand. But we know that Visual Studio can build this project. So I tried to see if I can use devenv.exe to build the project. I tried devenv.exe /? on the command prompt and found that it indeed takes a build switch. So I tried this devenv.exe MySetup.vdproj /build

That did not succeed. The following error message was spit out:

Microsoft (R) Visual Studio Version 9.0.30729.1.
Copyright (C) Microsoft Corp. All rights reserved.
—— Starting pre-build validation for project ‘MySetup’ ——
ERROR: Cannot find outputs of project output group ‘(unable to determine name)’.  Either the group, its configuration, or its project may have been removed from the solution.
ERROR: Cannot find outputs of project output group ‘(unable to determine name)’.  Either the group, its configuration, or its project may have been removed from the solution.
—— Pre-build validation for project ‘MySetup’ completed ——
—— Build started: Project: MySetup, Configuration: Debug ——
========== Build: 0 succeeded or up-to-date, 1 failed, 0 skipped ==========

I then decided to run it against the solution file devenv.exe MySolution.sln /Build

That did the trick. The setup files were created in MySolution/MySetup/Debug/ folder.

So I needed to integrate this into the build script. Using devenv.exe means this build machine needs to have Visual Studio installed on it. We already had it, so I was in luck. In some teams they might not allowed the build machine to have Visual Studio. 

I added the path to devenv.exe to the system path. Screen shot below should show you how to do that.

As a first attempt I added the following code to the AfterDropBuild target.

<Target Name="AfterDropBuild">   
    <Exec Command="devenv.exe $(SolutionRoot)/MySolution.sln /Build"/>
    <ItemGroup>
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/MySetup.msi" />
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/Setup.exe" />
    </ItemGroup>
    <Copy SourceFiles="@(SetupFiles)" DestinationFolder="C:\Temp\MSI" />
  </Target>

This attempt failed. The error message was not helpful. So I logged into the build machine and tried the same command from command prompt and nothing happened ! So changed the current directory to the location of the sln file and then ran the command again and it worked. So it seems that devenv needs only the name of the sln file (not the full path to it) and the current working directory needs to be the directory when the sln file resides.

So my second attempt:

<Target Name="AfterDropBuild">   
    <Exec Command="devenv.exe MySolution.sln /Build" WorkingDirectory="$(SolutionRoot)"/>
    <ItemGroup>
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/MySetup.msi" />
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/Setup.exe" />
    </ItemGroup>
    <Copy SourceFiles="@(SetupFiles)" DestinationFolder="C:\Temp\MSI" />
  </Target>

That worked ! Well not fully, but the Exec task worked but the Copy task failed. I found the reason for that was the files were getting created in the Debug folder and not the Release folder. In order to force a Release build I had to pass additional info to devenv. So I changed the script as shown below and I could see the bits were getting copied correctly.

<Target Name="AfterDropBuild">
    <Exec Command="devenv.exe MySolution.sln /Build &quot;Release|Any CPU&quot;" WorkingDirectory="$(SolutionRoot)"/>
    <ItemGroup>
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/MySetup.msi" />
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/Setup.exe" />
    </ItemGroup>
    <Copy SourceFiles="@(SetupFiles)" DestinationFolder="C:\Temp\MSI" />
  </Target>

Here is my final version for copying it to a remote drop location.

<Target Name="AfterDropBuild">   
    <Exec Command="devenv.exe MySolution.sln /Build &quot;Release|Any CPU&quot;" WorkingDirectory="$(SolutionRoot)"/>
    <ItemGroup>
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/MySetup.msi" />
      <SetupFiles Include="$(SolutionRoot)/MySetup/Release/Setup.exe" />
    </ItemGroup>
    <Copy SourceFiles="@(SetupFiles)" DestinationFolder="\\Build-Machine\Build_Drop_Folders\MyProjectMSI\$(BuildNumber)" />
    <Copy SourceFiles="@(SetupFiles)" DestinationFolder="\\Build-Machine\Build_Drop_Folders\MyProjectMSI\Latest_MSI" />
  </Target>

Note: Here $(SolutionRoot) is the path you have given while creating the build definition. You can see it by editing the build definition.

I don’t usually make new year resolutions. It is not because I am perfect and doesn’t need to make any changes, but it is because of my lazy nature. I have made up my mind several times in the past about achieving this and achieving that, but usually I don’t ever bring myself to completing my projects.

So why this year ?

I don’t know, but I think it would be a good thing to try. Like a new cuisine or a new hair style,  sometimes a change is nice to have – they add spice to life. So I am going to give new year resolutions a try this year.

So what is different this time ?

This time I am publicly disclosing the things I want to achieve, the projects I want to complete. I remember having read somewhere that it would be good idea to make our aspirations public. This would help motivate us to complete our projects.

As of now, I have 3 things in mind for 2010.

• I have decided to write a series of blog posts on the common software design patterns made popular by the GoF. Why design patterns? Frankly, I don’t have a very clear reason. I know it is not the hottest topic to blog about, but it is definitely a useful one. Especially for me. I have been reading about design patterns, and occasionally putting to practice, since some time in 2003 when Binil gave me The Design Patterns book. Since then, I have read a few more books on the topic. But I don’t claim to be master on the topic. Actually far from it, my understanding of many of the “advanced” patterns are still vague. Haven’t we all heard the age old adage – “the best way to learn something is to teach it.”. So I am going to write about them, which will help me understand them better and if someone is able to glean something from my posts, it will be a pleasant bonus. This would also be a good exercise in writing and keep the blog rolling.  
• Read some books. Not the kind of glancing over that I do nowadays. A thorough reading. Understanding the concepts and making it part of myself. This is pretty ambitious. As of now I have two candidates in my mind for this project. The first book is Structure and Interpretation of Computer Programs (I have had this book for 3 years now) and the second one is Domain Driven Design (been in my shelf for a little over 2 years). These are not easy books to read. But they are important books to have read for any computer programmer. As I mentioned before this is quite an ambitious target. 
• Visit some places. I have been in the US of A for about 3.5 years now. But I haven’t seen many of the good places here. Even in Washington state, there are so many good places to see. Now that I am married I have a travel companion too

I don’t know how much of this I can accomplish (as with all other things in the future). But I think it is worth a try.

Wish me luck.

If you need to have two Silverlight apps talking to each other, you would be using the LocalMessageSender and LocalMessageReceiver classes from the System.Windows.Messaging namespace. The LocalMessageSender class will only allow you to send string messages. So if you are looking to send strongly typed objects using the LocalMessageSender you will have to serialize the object and then deserialize it at the other end. I created a class which will do this work for you. I decided to use JSON as the serialization format because it is much more lightweight than Xml.

using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace Common
{
    public class JsonSerializer<T>
    {
        public static string Serialize(T objectToSerialize)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
                serializer.WriteObject(stream, objectToSerialize);
                stream.Position = 0;

                using (StreamReader reader = new StreamReader(stream))
                {
                    return reader.ReadToEnd();
                }
            }
        }

        public static T Deserialize(string jsonString)
        {
            using (MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
                return (T)serializer.ReadObject(stream);
            }
        }
    }
}

You can use this class like this

string serializedMsg = JsonSerializer<SimpleMessage>.Serialize(msg); 

SimpleMessage msg = JsonSerializer<SimpleMessage>.Deserialize(serializedMsg);

To give credit where it is due, I stole most of this code from here – http://www.silverlightshow.net/items/JSON-serialization-and-deserialization-in-Silverlight.aspx

If you need to have two Silverlight apps talking to each other, you would be using the LocalMessageSender and LocalMessageReceiver classes from the System.Windows.Messaging namespace. The problem with the LocalMessageSender is that it might not be able to send message at the very first try. So you will have to write code which retries to send the message for an x number of times. Rather than duplicating this code all over the place, I decided to create a class which will do this for you.

using System;
using System.Windows.Messaging;

namespace Common
{
    public class RetryMessageSender
    {
        private readonly int maxRetryCount;
        private LocalMessageSender messageSender;
        private int retryCount = 1;

        public event EventHandler<SendCompletedEventArgs> SendCompleted;

        public RetryMessageSender(LocalMessageSender messageSender)
            : this(messageSender, 100 /*default value of max retries*/)
        {
        }

        public RetryMessageSender(LocalMessageSender messageSender, int maxRetries)
        {
            this.messageSender = messageSender;
            this.maxRetryCount = maxRetries;
            messageSender.SendCompleted += new System.EventHandler<SendCompletedEventArgs>(messageSender_SendCompleted);
        }

        public void SendMessage(string msg)
        {
            messageSender.SendAsync(msg);
        }

        void messageSender_SendCompleted(object sender, SendCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                if (retryCount <= maxRetryCount)
                {
                    retryCount++;
                    SendMessage(e.Message);
                }
                else
                {
                    SendCompleted(sender, e);
                }
            }
            else
            {
                retryCount = 0;
                SendCompleted(sender, e);
            }
        }
    }
}

Now you can use this class like this:

RetryMessageSender msgSender = new RetryMessageSender(messageSender, 10);
msgSender.SendCompleted += new System.EventHandler<SendCompletedEventArgs>(msgSender_SendCompleted);
msgSender.SendMessage("hello");

In the SendCompleted event handler, you can check whether the message was sent successfully within the specified number of retries (10 in this case).

static void msgSender_SendCompleted(object sender, SendCompletedEventArgs e)
{
    if (e.Error != null)
    {
         throw new System.Exception("Unable to send message even after 10 retries");
    }
}

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            QuackTheQuacker(new Toy());
            QuackTheQuacker(new Duck());
        }

        static void QuackTheQuacker(dynamic quacker)
        {
            quacker.Quack();
        }
    }

    class Toy
    {
        public void Quack()
        {
            Console.WriteLine("A toy that quacks");
        }
    }

    class Duck
    {
        public void Quack()
        {
            Console.WriteLine("A duck that quacks");
        }
    }
}

I bought a new iPhone a few days ago and I am totally loving it. The only complaint that I have is the short battery time. If it could hold battery charge for a couple of days under heavy use, this would be the most perfect gadget I ever used. I am pretty sure Steve jobs have a few engineers working on it.

One of the things I like most about iPhone is the large number of neat apps available from the online store. I have always wanted to track my expenditures and i had made several attempts previously to do that using pen and paper as well as using a spreadsheet on a computer. The problem that I usually face is that I am not able to record transactions immediately. Usually I lose the receipt by the time I get to jot down the transaction or I just forget to do so. After a few attempts I just give up. With the iPhone I can immediately record the transaction using one of the many apps available to track expenses. I have already started using one.

Another good thing is the ability to tweet any time you want, assuming there is enough charge in the battery

There is a wordpress app in the iPhone using which i am writing this post. I am waiting at the Lynnwood DOL with Rija for her knowledge test and I decided to make use of the time to write a blog post. The touch keyboard is a little too small for my liking but it is works well under the space constraints. I had difficulty in typing initially but now I my speed has improved quite well. People with thick thumbs might have a more difficult time. I think most apps have a landscape orientation which allows for wider keys and less typos.

Our number in the queue is getting closer so I will have leave you now, my dear reader, and go to the counter.

Have a nice day !