My second mobile phone was another Sony Ericsson. It was the first mobile phone I bought. I was immensely excited the night I bought it, on way from work. The excitement of buying a new gadget is one that doesn’t ever diminish in its intensity, never goes away, no matter how many gadgets you buy. It is there right around the time you decide to buy a new gadget, and lasts well until after you’ve bought it. That was my second Sony Ericsson phone, and would be my last.

After I had made heavy use of it, I slowly moved away from it over to Nokia. I had a mammoth but reliable Nokia E61 lying around, which I was using for testing Symbian applications. Yes, this was roughly the time when I worked on Symbian application development. And that is all I am going to say of it.

My fourth and current mobile phone is a successor to E61: Nokia E72. I loved that phone when I bought it. I still love it in some ways. While E61 could be said to be too, E72 is what you would call a proper smart-phone. It features a lot of things that could help you do all sorts of things on the Internet, besides the usual functions of phone. It also has a full QWERTY keyboard. While I had owned an iPod Touch, I’d not been a big fan of touch screen and touch phones. I strongly believed that I could never be able to reliably use a phone with touch screen as the only form of input. This bias was in part due to my reliance on and affinity for physical QWERTY keyboards on phones.

Over the past couple of months, I was growing a little frustrated with my E72. While it worked as anyone would expect of it, I found that as far as applications that let me run wild on the Internet were concerned, it was severely limited. Sure, there were applications to do anything from using Facebook to Twitter to Foursquare. But I felt stifled. There were browsers but I didn’t feel the urge to browse anything on my mobile, unless it was an absolute emergency. I could post tweets on Twitter, but I didn’t enjoy interacting with others’ tweets. The same could be said of my experiences with Facebook (as far as I can tell, there is no native, official application for Facebook from Facebook for Symbian S60) or Foursquare applications. It just wasn’t fun, or even comfortable.

So for the past couple of months, I had been strictly debating getting an iPhone. iPhone 4S was out by then and it made no sense to get anything below that model. Some friends suggested time and again to go for the iPad instead. Where I was almost convinced that iPhone 4S would be my fifth phone, the recommendations for iPad threw my mind back in a state of confusion. Naturally, I compared the pros and contrasted the cons of both devices. Of course, one is a phone, the other a tablet, but when I compared the iPhone to the iPad, I actually compared it with iPad and my E72. That is, if I were to get an iPad, I would continue to use my E72 for the phone needs. There was a big difference in price as well, with a factory unlocked iPhone 4S coming at an exorbitant 67k PKR locally, while an iPad2 with WiFi cost only 48k PKR.

I still remember clearly the night I was at the club on the courts, playing tennis with my partner. He had finally bought the iPhone 4 a day before, after having looked for the white one for under a week. That night, I came home, and finally made up my mind.

The next afternoon, I was at the Apple Store I regularly buy from, purchasing an iPad2 WiFi with 16GB disk space. I had decided it. As I would find out, it was one of the best decisions I had made in my life in a while.

Those familiar with the different iPad2 models available will know that there’s a WiFi + 3G one available. Apart from having to pay under 10k PKR more, the main reason why I decided against getting the 3G model was the unavailability of 3G in the country. I know that you don’t necessarily have to have 3G to be able to use the connection, because any type of data-plan from your provider, such as GPRS or EDGE, will work. However, as I will explain, iPad is a content consumption device. When I say that it is a content consumption device, I mean it in a massive way. It has been designed for consuming a lot of content, including in the form of video, audio, and text. When I decided to buy it, I imagined myself using the iPad like I do my laptop. And I can’t ever imagine using my laptop over EDGE/GPRS in a way that satisfies me. Similarly, I didn’t think the iPad would shine on an EDGE/GPRS connection.

In the next post, I will explain exactly how the arrival of iPad has changed my life, how it has affected it, how I use it, where and when I use it. I will also list down the wonderful apps I use frequently, and make an argument for iPad being an awesome device for reading books/content in particular.

Lying in bed, trying to think of what if anything phenomenal I accomplished throughout the year that is no more I am forced to draw nothing. I can’t remember anything significant I did. That doesn’t mean I didn’t do anything worthwhile or significant to any extent. I just can’t remember. It’s probably due to the cracking headache I’m having. I don’t know.

The year passed by so quick, it’s hard to say where it went. I’m not the kind of person, as much as I try to be otherwise, who makes clear, real goals and lives by them. That doesn’t mean I’ve no goals. I do. I’m just not obsessed with the whole goal-setting thing. Although a lot of times I think that things around me simply unfold themselves, and I naturally flow through them.

Work wise, this was the year where I tackled many different projects, of varying complexities and sizes. I learned a lot of new things. Of import were my exercises in finding ways to deploy both Django and web.py Python frameworks on IIS on Windows. I went on to write a guide to deploying web.py on IIS which got accepted into the official cookbook documentation for the web.py project.

Insofar as tech gadgets are concerned, I was lucky enough to upgrade to the high-end Apple’s MacBook Pros, especially since my previous MacBook had developed several faults. Very late in the year I made what was perhaps the best decision in terms of buying anything when I bought the iPad2. It would be an understatement to say that it has had an impact on my life. The iPad has had a phenomenal impact on my life. If it is any testament to that statement, I’m writing this post on the Elements app on the iPad and will publish it using the WordPress app. I’m so glad I made the decision to buy it after much deliberation.

This year saw a lot by way of reading. I bought more books in paperback and committed myself to reading more. Not only that, I also forced myself to reading, daily, two dozen different interesting feeds. With the coming of the iPad, my reading saw an exponential increase, not only in the form of ebooks but many online feeds and content sources. A man must read, in order to survive. I believe strongly in that.

On the personal side, there were certain events that shook my life. It didn’t affect anyone’s but my own life, but they had a huge impact on me, and not sadly in positive ways. My emotional self took a battering. I also played a small part in helping save a friend’s life from half way across the globe. Thankfully, this year saw family bonds getting a little stronger, which I am very grateful for.

With regards to tennis, this was a great year for me. My game improved by leaps and bounds and I played some of the best tennis of my life. I have been more and more in love with tennis every passing day. Sometimes I think that that is the only true love left in my life.

All in all, I can’t say that the year was bad for me, nor would I want to say it was great. It was a balanced mix of both good and bad. Regardless, I’m thankful for everything and everything. I’ve been blessed beyond what I care to realise. You only need look at someone less fortunate than yourself to realise what you have been given. I do that almost everyday. And I feel bad about those severely less fortunate in particular. Yet I’m also guilty of forcing myself in a bubble at times that hides away the outside from me. I should always realise. I should always be grateful.

My best wishes to each and everyone of you. Please stay safe and be well! A very happy new year to you.

Thank you!

When younger brother sold our PlayStation 2 to buy an acoustic guitar to further his interest in music, my gaming world came to an abrupt halt. For a while after that, I didn’t really play games. It was well after I had started earning that I finally decided to revive my former, dormant self, and went out to buy the XBOX 360. To date, it is the console I have been happily playing games away. And I love it.

A week or so ago, I updated the firmware on the XBOX to the latest one available and got my hands to half a dozen games. Some that I’d care to name are: Batman Arkham City, Gears Of Wars 3, Skyrim, and Fifa 2012. Of particular interest to me was Batman Arkham City. It was one game I had been eagerly anticipating and looking forward to playing.

Half an hour into the game, I instantly fell in love with it. Everything about it. The gameplay in particular reminded me that of Assassin’s Creed 2, another game I thoroughly enjoyed playing. I was also very happy to learn that the game featured a very long story line. I saw myself having fun for a while with this game.

Until something hideous happened. It went on like this. I had the game installed on the hard-disk, so as to be able to preserve the lens on the XBOX. When I first ran the game, I decided to store saved game progress on the hard-disk as well. It all went fine. Until I had to take my XBOX over to a friend’s house for a game night. There we had to remove Batman from the hard-disk to make room for another game. I suspected deleting the game might also remove the saved progress on the disk, but on the assurances of friends, I took the bullet. The next day when I sat about playing Batman at home, I was taken aback to find that my saved progress on the game was gone. Zilch. Poof. There was nothing, as though there had never been anything. I felt incredibly sad. I blamed losing saved progress on the process on the deletion of the game from the disk–though, logically such a blame didn’t make sense.

Dejectedly, I sat about playing the game from the start, this time making sure to save progress on the memory card. I played over a couple of days, reached where I had left off, and moved ahed, happy with my progress.

This morning when I ran the game, I felt the exact same horror I did last week. The saved progress was gone again. It was nowhere to be found on the memory card. I searched everywhere, to no avail. I didn’t know what happened that could have caused it this time around. I yanked out the memory card and slid it into the second memory bay. Nothing. It was gone, without a trace. I felt betrayed. I let the game linger on the start screen, contemplating whether I should start over again. I couldn’t make up my mind.

And then on a whim, I ran a search on google to see if I could find any information on this erratic behaviour. Voila, I did. Many others on XBOX had reported similar issues as well as their resentment over them. This is the search I ran.

As far as I bothered to sift through piles of posts on forums and articles over the web, I couldn’t find any resolution for the problem. If anything it helped me come to a temporary decision: to hold off on playing the game again until a workable solution is found. Holding off isn’t something easy to do. It is such an awesome game, and I so much want to play it through the end. Oh well, off to play Skyrim!

The project in question is being tracked using Mercurial and has a history to it. By history, I refer to a set of change-sets (or commits, if you are a Git user not familiar with the use of change-sets to refer to commits). We had a user, let’s call them User A for the sake of clarity, who downloaded the source of the project at a particular change-set. Let’s call that change-set ‘Change-set X’. Note that User A didn’t clone the project repository and go back to Change-set X. They used the ‘get source’ convenience feature on BitBucket which makes possible downloading only the source of the project as it looks at a particular change-set or the tip of the repository (by tip, I refer to the last change-set recorded by the project). So, this User A got the source on their local system, and made some changes to the source. They unfortunately did all this without actually tracking the source under Mercurial, or any other version contorl system, for that matter.

Let’s introduce User B. User B is another contributor on the project. However, they have a clone of the repository on their local machine, and contribute changes and additions through their tracked working copy. User B committed and pushed several changes since Change-set X. All these changes were visible on the remote repository on BitBucket for the project. Now is when the problem came to be about. Both User A and User B now wanted the changes User A made to their private, untracked copy to be merged and pushed to the remote repository, so that they were available to User B. How do they go about doing it?

The biggest hurdle here was that the copy User A had wasn’t tracked under Mercurial at all. That meant that it had no history, nothing of the sort. It just wasn’t being tracked.

I thought about this. After much thinking, I came to a plan that I thought would be worth giving a go at. The plan was like this. First of all, User A had to initialize a Mercurial repository on the local copy that they had made changes to. This would create a new repository. Next, they had to push the changes upstream to the remote repository on BitBucket. However, when they did that, Mercurial aborted, and complained about the local repository being unrelated to the remote repository. Having looked around for what that really meant, I found out that Mercurial complained in that tone whenever the root or base change-set on two repositories were missing or different. This was indeed the case here. However, reading the help page for the “hg push” command, I noticed the “–force, -f” switch, with a note that said that this could be used to force push to an unrelated repository. For what it’s worth, the forced push worked, in that, it was able to push the changes on to the remote repository. It did mess the history and the change-set time-line a bit, because the change-sets from User’s A copy had a different base and parent than those that were on the tip on the remote repository. As far as User B was concerned, when they pulled the latest changes from the repository, they had two dangling heads to deal with and had to merge. The merge resulted in a lot of unresolved files with marked conflicts. Since I wasn’t familiar with the changes in the project, I didn’t pursue User B (and User A) after this point.

While wondering what could be a better way to handle this situation, I posed the question on the #mercurial IRC channel on FreeNode. User “krigstask” was kind enough to provide a solution. His solution went like this. User A would clone the remote repository on their local machine.

$ hg clone URL cloned-repo

They would then jump back to Change-set X.

$ cd cloned-repo
$ hg update -C change-setX

They would copy recursively the changes from their local, untracked copy of the repo into their working copy.

$ cp -r /path/to/local/untracked/repo/* .

They would go through the diffs to ensure their changes are there.

$ hg diff

They would commit their changes.

$ hg commit

Finally, they would merge their commit with the tip of the repo.

$ hg merge

In hindsight, this is a cleaner approach that actually works. I wondered why it didn’t cross my mind when I was thinking about a solution. Many thanks to “krigstask” for taking the time out to explain this approach to me.

I hope I was able to provide something helpful for my version control readers in particular and everyone else in general.

To paraphrase Seneca, the tragedy isn’t that life is short, the tragedy is that we waste so much of it.

The other types of tragedy, the more violent kind, never worry me too much, thankfully. I never lost much sleep, worrying about wars or serial killers or whatever.

But the thought of getting to the end of my life and realizing that I had wasted most of it, that froze my blood.

As it should…

To this day, I remember that day in the summers of 2008 when I decided to pack and seal my laptop inside my cupboard, and board a one-way plane to Quetta to spend a month with relatives away from everything I did at home, far, far away from any form of technology. All I had when I reached the airport were a bag full of clothes, a book, and my cellphone (I decided to carry so that I could keep in touch with parents).

One month later when I returned, I had an incredibly painful realization dawn on me. I felt I had wasted an entire month of my life doing absolutely nothing. I thought of all the ways in which I could’ve spent that month that would’ve meant something meaningful to me, or of all the productive things I could’ve done that would’ve helped me and/or my never ending quest for knowledge and for doing things that matter. I couldn’t come to terms with the fact that I had wasted over thirty days, doing nothing more than resting, reading a book that was purely fiction, and socializing with limited relatives.

People take breaks, vacations, to cut themselves away from their hectic lives in order to refresh themselves, to revitalize themselves, to save themselves from the risk of burning out. When they come back to their lives after such breaks, they feel energized  and ready to again take on the mountains that lay before them.

I took a vacation, I took a break. I took rest, I cut myself away from technology, from the usual things that made up my hectic life. But when I came back, I didn’t feel energized. I didn’t feel revitalized. I felt regret. I felt slow and lethargic. I felt angry at myself for having wasted so much time doing nothing.

To this day, I live with that regret. I understand that regrets are harmful and best thrown away, but that’s one of those things that are easier said than done.

To get back to the important question of deploying a web.py script on IIS7 using PyISAPIe, I will make it such that this guide will list down various steps I took, including snippets of relevant code I changed, to tame the beast. I can only hope that what is below will help a poor, miserable soul looking for help as I did (and found none).

I worked with PyISAPIe because I had successfully deployed multiple Django websites on IIS7 on it. The script in question was going to be a part of another Django website (though acting independently). It only made sense to use PyISAPIe for it as well.

First and foremost, I had to install the web.py module on the system. Having had trouble before with IIS with web.py installed through easy_install, I decided to be safe and installed it from source.. Getting web.py to work with PyISAPIe required a small hack (I notice I may make it sound as though it all came down to me in a dream, but in reality, it took me days to figure it out, and clearly after much anguish and pain). In the file Lib\site-packages\web\wsgi.py lies the following function:

def _is_dev_mode():
    # quick hack to check if the program is running in dev mode.
    if os.environ.has_key('SERVER_SOFTWARE') \
        or os.environ.has_key('PHP_FCGI_CHILDREN') \
        or 'fcgi' in sys.argv or 'fastcgi' in sys.argv \
        or 'mod_wsgi' in sys.argv:
            return False
    return True

In its pristine state, when web.py is imported from a source file through PyISAPIe, an exception is thrown. The exception, while I don’t have the exact message, is about it complaining about sys.argv not having an attribute argv, which reads fishy. Since the function _is_dev_mode() only checks whether web.py is being run in development mode, I thought I didn’t care about it since I wanted everything to run in production mode. I edited the function such that its body would be bypassed, while it returned a False boolean value. It looked like this (the important changes I made are highlighted):

def _is_dev_mode():
    return False
    # quick hack to check if the program is running in dev mode.
    if os.environ.has_key('SERVER_SOFTWARE') \
        or os.environ.has_key('PHP_FCGI_CHILDREN') \
        or 'fcgi' in sys.argv or 'fastcgi' in sys.argv \
        or 'mod_wsgi' in sys.argv:
            return False
    return True

This innocuous little addition did away with the exception.

Next up, I used default Hello World-esque example of web.py found on their site to test the deployment (of course, I went on to use my original API script, which was far too complex to trim down and fit into as an example). I called it code.py (I placed it inside the folder C:\websites\myproject). It looked like this:

  import web
  urls = (
      '/.*', 'hello',
      )
  class hello:
      def GET(self):
          return "Hello, world."
  application = web.application(urls, globals()).wsgifunc()

It was pretty simple. You have to pay particular attention on the call to web.application. I called the wsgifunc() to return a WSGI-compatible function to boot the application. I prefer WSGI.

I set up a website under IIS using the IIS Management Console. Since I was working on a 64-bit server edition of Windows and had chosen to use 32-bit version of Python and all modules, I made sure to enable 32-bit support for the application pool being used for the website. This was important.

I decided to keep the PyISAPIe folder inside the folder where code.py rested. This PyISAPIe folder contained, of import, the PyISAPIe.dll file, and the Http folder. Inside the Http folder, I placed the most important file of all: the Isapi.py. That file could be thought of as the starting point for each request that is made, what glues the Request to the proper Handler and code. I worked with the Examples\WSGI\Isapi.py available as part of PyISAPIe. I tweaked the file to look like this:

from Http.WSGI import RunWSGI
from Http import Env
#from md5 import md5
from hashlib import md5
import imp
import os
import sys
sys.path.append(r"C:\websites\myproject")
from code import application
ScriptHandlers = {
	"/api/": application,
}
def RunScript(Path):
  global ScriptHandlers
  try:
    # attempt to call an already-loaded request function.
    return ScriptHandlers[Path]()
  except KeyError:
    # uses the script path's md5 hash to ensure a unique
    # name - not the best way to do it, but it keeps
    # undesired characters out of the name that will
    # mess up the loading.
    Name = '__'+md5(Path).hexdigest().upper()
    ScriptHandlers[Path] = \
      imp.load_source(Name, Env.SCRIPT_TRANSLATED).Request
    return ScriptHandlers[Path]()
# URL prefixes to map to the roots of each application.
Apps = {
  "/api/" : lambda P: RunWSGI(application),
}
# The main request handler.
def Request():
  # Might be better to do some caching here?
  Name = Env.SCRIPT_NAME
  # Apps might be better off as a tuple-of-tuples,
  # but for the sake of representation I leave it
  # as a dict.
  for App, Handler in Apps.items():
    if Name.startswith(App):
      return Handler(Name)
  # Cause 500 error: there should be a 404 handler, eh?
  raise Exception, "Handler not found."

The important bits to note in the above code are the following:

• I import application from my code module. I set the PATH to include the directory in which the file code.py is so that the import statement does not complain. (I’ve to admit that the idea of import application and feeding it into RunWSGI came to while I was in the loo.)
• I defined a script handler which matches the URL prefix I want to associate with my web.py script. (In hindsight, this isn’t necessary, as the RunScript() is not being used in this example).
• In the Apps dictionary, I again route the URL prefix to the lambda function which actually calls the `RunWSGI` function and feeds it application.
• I also imported the md5 function from the hashlib module instead of the md5 module as originally defined in the file. This was because Python complained about md5 module being deprecated and suggested instead of use hashlib.

And that’s pretty much it. It worked. I couldn’t believe what I saw on the browser in front of me. I danced around my room (while hurling all kinds of expletives).

There’s a caveat though. If you have specific URLs in your web.py script, as I did in my API script, you will have to modify each of those URLs are add the /api/ prefix to them (or whatever URL prefix you set in the Isapi.py. Without that, web.py will not match any URLs in the file.

What a nightmare! I hope this guide serves to help others.

Thank you for reading. Good bye!

PS: If you want to avoid using PyISAPIe, there is a simpler way of deploying web.py on IIS. It is documented crudely over here.

     I recently found a command line utility on OS X to release most of inactive memory. It is called, “purge”. The short description for “purge”, from its man page, states that its use forces the disk cache to be purged. The “disk cache” actually refers to “inactive memory”. To run this command, you have to type “purge” on Terminal.app (or any other Terminal application that you use). For example:

(Ayaz@mbp) [0] [~]
$ purge

     Before running the purge command, the memory breakdown on my system looked like:

     After the purge command ran, inactive memory went from 858MB down to 270MB.

     You will notice that the system becomes a little unresponsive while purge is flushing the disk cache. That’s fine and nothing to worry about.

     If you can’t find purge on your system, it could be because you have not installed XCode and accompanying development tools. These are available in one of the OS X installation discs. You can now also pay and download XCode from the Mac App Store.

     Have fun and be nice!

import socket
ip_list = [ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.")]


     While this piece of code does find a public IP listening on any of the available interfaces, its restriction lies in not being able to return all public IPs on interfaces: It gives back just one IP.

     This wasn’t clearly sufficient. I looked around again, and this time, found a third-party Python module called pynetinfo. This module could make possible working with different network device settings.

     I rearranged the code around pynetinfo and produced this:

def get_inet_ips():
  try:
    import netinfo
  except ImportError:
    return None
  else:
    inetIPs = []
    for interface in netinfo.list_active_devs():
      if not interface.startswith('lo'):
        ip = netinfo.get_ip(interface)
        inetIPs.append(ip)
    return inetIPs


     The code above loops through all available and active interfaces on the system, fetching and storing their IP in a simple datastructure. That got me all of the IPs available to a machine, excluding the loopback one, which the code was set to discard.

     But that wasn’t it. There was a slight problem. Not all the active interfaces on the system had public IPs. Some had private, local LAN IPs in the 192.168.0.0/16 and 10.0.0.0/8 subnets. The code above was returning all the IPs it could find, including public and private ones.

     I then found the netaddr third-party Python module which provided a Pythonic means of manipulating network addresses. I modified my code to use the netaddr module and got the following to boot with:

def get_inet_ips():
  try:
    import netinfo
    from netaddr import IPAddress, AddrFormatError
  except ImportError:
    return None
  else:
    inetIPs = []
    for interface in netinfo.list_active_devs():
      if not interface.startswith('lo'):
        ip = netinfo.get_ip(interface)
        try:
          ip_address = IPAddress(ip)
        except AddrFormatError:
          continue
        else:
          # If the IP is not private, use it.
          if not ip_address.is_private():
            inetIPs.append(ip)
    return inetIPs


     The netaddr.IPAddress.is_private() method in the code above determines whether the given IP is part of any of the defined private networks.

     Admittedly, there is much room for improvement in the code above. I can only hope that if it doesn’t help, then at the very least it serves as an interesting read.

     What’s special about today is that we moved most of our Mercurial repositories to BitBucket.org. While they will remain private, the contributors as well as the internal non-contributors will be given access to them. Aside from having the repositories on a central server that we can mostly always rely on, having a lovely Web interface to browse and control the repositories, we also get useful goodies like issue trackers, wiki pages, and an easy user management interface. It is a win-win situation for everyone.

     One of the projects I was working on had only been on a local Git repository. I started work on it at a time when I found myself deeply in love with Git. Since BitBucket is a Mercurial repository warehouse, I had to find a way to convert or migrate the Git repository into a Mercurial one.

     I looked around on the Web and found a lot of people recommending the use of the HgGit plugin. As I understood it, this plugin made possible, among other things, the workflow that involved working on a Git repository and pushing the changesets to a Mercurial counterpart. However, the process of setting it up seemed rather complex to me. Plus, I didn’t want to keep the Git repository lying around when I was done with the migration. I wanted to be able to migrate the Git repository to a Mercurial one, push it upstream to BitBucket and make any changes in future in the source code by cloning from the Mercurial repository. What HgGit did seemed rather overkill for my needs.

     I then discovered the Mercurial ConvertExtension. This extension did just what I wanted: Convert repositories from a handful different SCMs into Mercurial. The process of converting a Git (or any other repository) to a Mercurial one through ConvertExtension is very straightforward.

     As a first step, you are required to edit your global .hgrc file to enable the extension thus:


[extensions]
hgext.convert=


     You are then required to run the hg convert command on your target Git repository thus:


$ hg convert /path/to/git/repo


     This will migrate the Git repository, and store it in the current directory inside a directory named repo-hg. Once inside the newly created Mercurial repository (and this part is important), you have to run the following command to checkout all the changesets:


$ hg checkout


     You may then push the repository with the usual hg push to BitBucket.

     :)

     PS: This blog post really helped get me going in the right direction.

     For a recent mobile website project that I worked on, I had to face a complaint from the client where the layout of certain pages on the site didn’t look quite as expected on BlackBerry devices. Naturally, I didn’t have a BlackBerry handset nor an easy equivalent to test the issue for myself, so I did what anyone stuck in the same corner as I would do: I went over the BlackBerry developer portal online to look for BlackBerry simulators.

     Unlike the Epoch simulator for Symbian/Nokia phones and the iPhone simulator, the BlackBerry simulators were spread out such that for each possible BlackBerry smart-phone model in existence, there was a simulator available for it. And each one of the download was anywhere from 50 to 150 MB in size.

     I chose the simulator for one of the latest BlackBerry handsets, and downloaded it. Like the Epoch simulator, BlackBerry simulators are Windows-specific, in that, they are available in the form of Windows executable binaries. I didn’t have Windows anywhere in my study, so I had to set up a Windows guest inside VMware Fusion in order to set up the simulator. To cut a long, painful story short, I was able to install the simulator after tirelessly downloading a big Java SDK update, without which the installation wouldn’t continue. And then, I powered up the simulator. I was instantly reminded of the never-ending pain I had to suffer through the hands of the Epoch simulator in my previous life where I used to be a Symbian developer. The BlackBerry simulator took ages to start up. I almost cursed out loud because that fact alone opened up old, deep gashes that I had thought I had patched up for good. I was mistaken. Never in my dreams had I thought of having to deal with such monstrosity ever again. And, to my utter, absolute dismay, here I was.

     Eventually, after what seemed to have been ages since I booted up the simulator, I was able to navigate my way to the BlackBerry browser. I let out a deep sigh and thought that I could now finally concentrate on the problem I set out to tackle. But, no! I couldn’t browse on the BlackBerry browser at all. No amount of fiddling with the 3G and WiFi settings all over the BlackBerry OS got browsing working. From what I could tell, both the 3G and WiFi networks were alive, but there was no traffic flowing through. I almost gave up.

     After groping on the Internet with a wince on my face, I was finally able to find out why. Apparently, by default, the BlackBerry simulator are unable to simulate network connections. In order to do this, you have to download and install an additional, supplementary BlackBerry simulator that is called the BlackBerry MDS Simulator. Once this simulator is up and running, your actual BlackBerry simulator will be able to simulate network connections, browse, and do all sorts of network related functions. Who knew!

     As an aside, there’s also the BlackBerry Email Simulator that simulates messaging functionality.