.::output >> /dev/null::. :

Making Objective-C Land More Habitable

Thu, 17 Dec 2009 13:58:00 -0800

Over these past few months, I have been working on a long-term class project using OS X technologies in both Objective-C and Javascript. Overall, the experience was pretty good (except for the Javascript part) -- and I suspect much easier compared to having to use Java. Using Java would require us to hunt down various libraries and then filter through them since there are probably 10++ different libraries for each thing that we need to do. So using OS X was a good choice.

However, there are a few tools that I wished I had known earlier....

GHUnit

Unit testing using Cocoa is pretty complicated. In fact, it's unnecessarily more complicated than Java, Ruby or Smalltalk. It's only less complicated than unit testing C++ (which doesn't say much)! There are two things that particularly irk me:

Not seeing green/red! - You have to actually read the text in the build log to see which of your tests pass and fail. This is completely ridiculous - it's so easy to miss a failing test case because of this. Anyone who has used the Xunit testing framework family is accustomed to seeing green for passing tests and red for failing tests.

A Failed Test Logged in the Xcode Build Results Window
Not being able to debug your unit tests - You have to perform some boilerplate steps on your own. Such steps should be automated for you!

Fortunately, GHUNit comes along. And at least solves those two problems. It has become my choice for unit testing in Cocoa and all my future projects will use it. It's released under a very liberal open source license so using it in your own project shouldn't be a problem. Apple and the Xcode team should integrate this directly into Xcode.

GHUnit in action

F-Script

The cocoa libraries are nice. But sometimes the documentation can be a bit confusing. So, the best way to find out what a method or class does it to write some code for it and try it out. But honestly, would you like writing a small program each time to try a method or class out?

That's when you need F-Script which allows you to call run Objective-C like you would run a scripting language. Need to find out how that NSString method behaves? Just type in into the F-Script REPL workspace. You can even play around with Core Image easily in the F-Script workspace!

F-Script shell in action

But wait! F-Script has even more to offer. Using F-Script Anywhere allows you to inject the F-Script environment into any Cocoa application. That way you can quickly figure out and play around with other people's application!

The only thing you need to do is spend about 20 minutes learning the F-Script syntax which is very similar to Smalltalk's - so it only took me about 5 minutes.

Clang Static Analyzer

One area where Java really shines is the abundance of high-quality tools for static analysis. Using these tools allow you to avoid a lot of silly mistakes before you even compile or run your Java code.

Previously, Objective-C was definitely lacking in this area. However, the Clang Static Analyzer hopes to change that. In fact, if you are using the latest version of Xcode under Snow Leopard, it should be integrated already. Here's the static analyzer in action:

Uninitialized Variable Error

For our particular project, we needed to use OS X Leopard so followed these steps to get the static analyzer to work. Even though it took a few more steps, the extra trouble is worth it since it catches a lot of garbage collection issues that we might have missed otherwise.

The Clang Static Analyzer is based on the LLVM compiler infrastructure developed here the University of Illinois at Urbana-Champaign.

BWToolkit

Interface Builder is awesome. It definitely beats any other interface builder that I have tried. However, it can be too basic at times. It works very well, if you are doing a simple UI. But it lacks the palettes for some of the more advanced (but pretty commonplace) UI that you see in Mail.app, iCal.app, etc.

That's when BWToolkit comes in. It offers a plethora of different palettes which makes designing your UI extremely easy. And you can use all of them using drag-and-drop from Interface Builder.

BWToolkit's suite of controls for HUD windows

It's released under the liberal BSD license so you don't need to worry about using it for your projects. GHUnit itself uses it and that's actually how I discovered this wonderful toolkit.

Overall, OS X has a lot to offer in both libraries and tools. And when it falls short, some other developer out there is usually passionate enough to create and share their tools with you. It just takes too long sometimes to find those tools. So hopefully, this list will be useful to some other aspiring OS X developer.

Modifying plugin.xml of Existing Eclipse plugins

Sun, 11 Oct 2009 17:10:00 -0700

I have been taking a deeper look at Mercurial for some of my projects. And I was interested in looking at its source code. I usually do a lot of Java development and have gotten used to all the nifty navigation features that Eclipse/NetBeans/IntelliJ have to offer such as "Jump to Declaration", "Open Type Herarchy", etc. So I wanted to find a good IDE for going through the Mercurial source code, which is written in Python. Apparently, there isn't a de-facto IDE for Python. But PyDev comes close.

Unfortunately – I am not sure whether this was intentional or not – the keyboard shortcuts for PyDev aren't very platform friendly. Instead of the default modifier key (Ctrl on Windows/Linux and ⌘ on Mac) the developers have hardcoded the modifier to Ctrl for all platforms. So to invoke the I would have to use Ctrl + Shift + T instead of ⌘ + Shift + T.

So how do we change the keybindings? Well, there is an extension point in the Eclipse plugin architecture for specifying the keybindings. Take a look at org.eclipse.ui.bindings And those keybindings are stored as plain text in a plugin.xml file. For PyDev, it would be in the plugins folder of your Eclipse installation. In my case, it was under eclipse-galileo/plugins/org.python.pydev_1.5.0.1251989166/plugin.xml

So we can edit the plugin.xml file by looking for the

      ...
      <key
            sequence="Ctrl+Shift+T"
            contextId="org.python.pydev.ui.editor.scope"
            commandId="org.python.pydev.editor.actions.pyShowBrowser"
            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
      </key>
      ...

and changing the Ctrl to M1 which stands for the default modifier key on your platform i.e.

      ...
      <key
            sequence="M1+Shift+T"
            contextId="org.python.pydev.ui.editor.scope"
            commandId="org.python.pydev.editor.actions.pyShowBrowser"
            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
      </key>
      ...

Unfortunately, we are not done. And it took me some time to figure out the problem. Apparently, Eclipse doesn't read the plugin.xml every time. Instead, it caches a version of it somewhere. So even if we modify the plugin.xml, Eclipse might not know about it.

What we have to do is to tell Eclipse to clean its cache. And we can do that by using the -clean option in its eclipse.ini file. On the Mac, this file in located in Eclipse.app/Contents/MacOS/eclipse.ini (you need to right-click on the Eclipse application and select "Show Package Contents").

Change the first line so that it read something like this:

-clean
-startup
../../../plugins/org.eclipse.equinox.launcher_1.0.201.R35x_v20090715.jar
--launcher.library
...

Now when Eclipse starts up, it will clean its cache and read the newly modified plugin.xml file. Once we are done with this step, we should remove the -clean option since this causes Eclipse to start up slower. And who would want Eclipse to start up any slower than it already does?!

And this is what the keybindings look like after the changes:

Hacking Lua (in Xcode)

Sun, 15 Feb 2009 13:03:00 -0800

I have always been fascinated by application virtual machines. And I have been trying to find a simple but well-documented one to work on for fun. There is a proliferation of Javascript VMs out there but they are pretty big (V8 is the latest kid on the block and it's about 100 000 lines of C++, not my favorite language) and aren't as well documented.

There are some smaller ones like tinyrb and tinypy but the goal of such projects aren't really clear. I am not sure how much of Ruby/Python they are trying to support. They are great for hacking on if you have some experience with VMs already and can contribute to the design/implementation. But otherwise, it can be pretty hard to comprehend what is going on.

Both tinyrb and tinypy did mention that they were trying to emulate the Lua VM. So I decided to check it out. The Lua VM (like the Parrot VM) is a register-based VM, which is pretty unusual since most VMs are stack-based. Its use of registers instead of a stack makes it more fascinating to study.

And I like what I have seen so far. There is good documentation on multiple levels: the language itself, the architecture of the VM and plenty of examples. Also, the code is in C which is less messy than C++. The Makefile is simple and isn't using any cryptic tricks. And Lua itself seems like a simple language to learn.

So my plan is to dive into the source for Lua and then see what can be done to improve tinyrb. But first, I need to set up an environment to develop in.

I could certainly continue to use vim/TextMate, but I have been using Xcode more because I am doing some iPhone development and have gotten use to some of its features. And I like its built-in debugger which saves me from having to interact with gdb directly for the common tasks. In fact, I am not sure if there are better C/C++ IDEs for OS X. The Eclipse CDT project is the closest that I can think of but I haven't used it much.

So here are my steps for doing this: from getting the source into Xcode and also starting a debugging session. I am using the All-in-one look for Xcode so your UI might look different.

Grab the source for Lua-5.1.4 from http://www.lua.org/ftp/lua-5.1.4.tar.gz. Unarchive it. For this article, I will be unarchiving it in ~/Xcode.

Fire up Xcode and create a new External Build System project. I called my project Lua. You can put the project wherever you want. It doesn't need to be in the same directory where you unarchived the Lua source code since we will be referencing the source files anyway.

Right-click on the project and add the entire directory where you unarchived the Lua source code. In my case it would be ~/Xcode/lua-5.1.4.

This is what it looks like after adding all the files.

Next, we need to edit two of the Makefiles. First, we need to edit the top level Makefile in ~/Xcode/lua-5.1.4. Change line 8 to PLAT= macosx since we are targeting the OS X platform. Then, we need to make changes to the Makefile in ~/Xcode/lua-5.1.4/src. Change line 17 to MYCFLAGS+= (we want the + symbol). Change line 108 to $(MAKE) all MYCFLAGS+=-DLUA_USE_LINUX MYLIBS="-lreadline" (again, we want the + symbol). In fact, by default, it should have the + symbol so that we can easily accumulate our own settings. I suspect that this is a careless omission in the Makefile for Lua.

We need to make some changes to the Target configuration for our Project. So navigate to the Lua target in your Groups & Files (it's the left navigation pane). And double-click the Lua target. Then edit it so that it resembles the image above. Notice the line that says "Settings show Debug" near the top of the window; we are changing the settings for Debug (and not Release).

You need to change the directory to the location where you unarchived the Lua source so that it can find the top-level Makefile.

Then you need to add a new build setting, MYCFLAGS so that we can pass the -g flag (for debug) to the compiler. Without this flag, we cannot debug our program effectively with the debugger (it doesn't have all the necessary debugging information).

Now we can build our project by going to Build > Build. And notice that we are building for the Debug configuration i.e. on the menu item at the top it says 10.5 | Debug | i386. The settings that we made for our Lua target are reflected in the output of the build e.g. gcc -O2 -Wall -g .... (the -g flag that we specified in the settings).

Now that the project builds, we can proceed to debug it (or rather we just want to step through its execution in the debugger to find out how it works). The image above shows how we would run that executable (notice that we are passing some arguments to it). We want mimic this and run the program in the debugger.

So we create a new Custom Executable. We call it Lua.

In the dialog that pops-up, remember to specify the location of the lua executable (you will only have it after you have built the project).

Before we can debug the lua executable, there is one more setting that we have to perform: change the way debugging symbols are loaded. So, open up the preferences for Xcode, and switch to the debugging tab. Ensure that the "Load symbols lazily" is unchecked.

Now we need to set a breakpoint. Notice in the image above that I have set one on line 378 in the lua.c (Xcode/lua-5.1.4/src/lua.c) file. After that we can invoke the debugger from the Build > Build and Debug menu.

And finally we have our debugger in action.

The steps above are applicable for any other external project that you need to work on (sans the modifications to the Makefiles since that is Lua-specific).

Online Gradebooks - Something Worth Hating

Fri, 19 Dec 2008 17:18:30 -0800

Instructor Help: Reorder Grade Book Columns:

"The following tutorial shows how to reorder and hide/show columns in the Grade Book. Each Grade Book view tab (Grades, Members, View All, Custom View, SCORM Grades) has its own independent display order. The order for a specific view tab can be changed by pressing the Reorder Columns button when viewing that tab. If you wish all of the views to display in the same order, use the Reorder Columns button for each view."

The University of Illinois uses the same grading system that the University of Idaho does. And it is fortunate too since I was having a hard time trying to figure out who to reorder some of the columns. It is so hard that I actually need to search for instructions on how to do it from the internet. It is always a bad sign when something as simple as reordering some columns requires the user to read a manual.

I had optimistically assumed that in this modern age of AJAX that a mundane task like reordering columns was basically solved. I was proven wrong.

Before you read more, it might be best to read the instructions above first to see how unintuitive the UI is for the Blackboard Learning System really is.

Compare this to how a simple (and useful app) like Basecamp does it:

Basecamp help: To-do lists:

"To the left of each title, you'll see the reorder icon (it looks like four arrows). Click the icon and drag the list up or down to the location you want."

Simple: drag-and-drop.

And to make matters even worse, the entire Blackboard system is written in Java, takes a long time to load and does not even take advantage of all that Java has to offer. I am sure someone can come up with a better UI in Java. How hard can it be to support drag-and-drop in Java?

No one (student or instructor) that I have talked to likes using this online gradebook. So it really makes me wonder, is this the best that software developers can do for online gradebooks? Or is it this bad just because there aren't enough competitors in this field?

Who The Hell is Bob Costas?

Fri, 08 Aug 2008 19:47:00 -0700

At the recommendation of my mom back home, I decided to watch the opening ceremony of the 2008 Summer Olympics. Disappointingly, I did not have right cable package so I could not watch it live with them.

Instead, I had to wait until 7:30 pm (it was happening live at around 7:00 am local time in Beijing) to watch the delayed telecast on NBC. I was actually looking forward to it based on what I had heard and read from the Internet earlier today.

The telecast started off well with the spectacular performances in the Bird's Nest stadium. I was really impressed by what the Chinese had put on. By this point, the commentator had already begun to annoy me a bit with his weird, uncalled-for and out-of-place comments. But there was nothing really bad about his comments yet.

Then the time came for all the contingents to come marching in. And here is where Mr. Bob Costas started making all sorts of weird comments. I cannot remember all of them, so I have to paraphrase it.

"Of the xxx number of countries participating here, most of them will not receive a medal".

"Malaysians are rather particular about people knowing where their country is. They get upset when people don't. So let's see where the country is...."

"The president of xxx promised that the athlete who brings home a medal will be awarded a dream house... looks like he has nothing to worry about since there probably wouldn't be one."

"This nation's flag bearer was chosen through a series of text messages. She had 73% of the votes. I bet she was sitting there texting in her name all day..."

"And here are the xxx who have won more medals at the Math Olympiad..."

... And many others that I can't remember. I am sure someone else will blog about this soon.

I don't think I am overly sensitive to his comments. I can definitely take a joke or too, but the inanity of his comments just puts me in an unhappy mood.

It seems that this is not the first time he has done something like this. His wikipedia entry tells of his past faux pass (if one can still call them that; they seem more like verbal crimes):

"During the 1992 Barcelona and 1996 Atlanta Opening Ceremonies, Costas' remarks on the China Team's possible drug use caused an uproar among the American Chinese and International communities. Thousands of dollars were raised to purchase ads in the Washington Post and Sunday New York Times, featuring an image of the head of a statue of Apollo and read: 'Costas Poisoned Olympic Spirit, Public Protests NBC'."

I will be looking forward to the closing ceremony but hopefully not with Bob Costas. I am also rather surprised with NBC's decision to put Bob Costas as one of the commentators given his less-than-impressive history with making such blunders.

A Pattern Language for Screencasting

Mon, 02 Jun 2008 19:24:02 -0700

About 9 months ago, I said that I will be looking into collecting different patterns for screencasting. So finally....

I just finished writing a pattern language for screencasting based on my experiences producing and observing various screencasts on the internet. Through my experiences I have noticed various patterns that myself and other screencasters have used. Applying those patterns would certainly help the presentation of your screencast but, more importantly, I believe that the patterns enhance the teaching-learning experience of screencasts. And ultimately that is what matters most.

Interested readers may view the patterns here. The pictures that I have included are based on software for the Mac since that is what I use for my screencasting.

At the moment, it's a rather complete version of what I had originally envisioned for such a document. It can definitely be improved but I would like to get a version out on the web for people to read in case anyone is interested in providing feedback or suggestions.

I do maintain copyright on the document in case I ever decide to publish it at some pattern conference.

Antony Blakey's Efforts on VisualWorks

Fri, 30 May 2008 16:10:00 -0700

The end of LLVM/WebKit VW integration and layout improvements.:

"Over the last 18 months or so I've put a lot of work into enhancing VisualWorks with WebKit integration, GCCXML, and later LLVM integration, as well as improving the GUI layout system. I've stopped development on these projects, primarily because there seems to be no external interest in these projects."

I am really sad that Antony Blakey is going to stop work on the GUI layout improvements for VisualWorks. His work actually made the VisualWorks UI pleasant and usable. Here's a screenshot to illustrate what I mean.

On the left is the version enhanced with Antony's packages. And on the right is the original UI look of VisualWorks for the Mac. Notice how the tabs, find menu bar and the fonts look so out-of-place for the version on the right. And notice how they look more native for the version on the left. If you just glanced at this you might not find them to be much different but if you had to use the layout everyday, which would you actually prefer?

I am glad that he has pushed his GUI layout work onto the Cincom public repository so we could actually look at it and modify them as necessary. A cursory glance reviews that all of the code is written in Smalltalk without the need for calling C code. So there is the possibility that I can actually decipher the code and make changes if necessary. I am not an expert on VisualWorks so this might still prove to be rather challenging.

On the other hand, while I am definitely impressed by his work on LLVM/WebKit integration, I am not sure if I have the right level of knowledge to hop on board and contribute. I definitely would like to and perhaps after a year of using VisualWorks I would be able to. But right now, I wouldn't be of much help. Moreover, if I read his blog entries on these subjects correctly, the LLVM/WebKit integration involves diving into the VM source code and actually changing the internals of the system. I think it even requires a custom version of the VM. Also, he hasn't pushed all of his work on LLVM/WebKit integration onto the store (he has an interesting article on why the Cincom public store is not really suitable for collaborative development)

Most people might argue that the VisualWorks UI is actually much better than the one for Squeak with all its colorful windows and non-standard layout. But here's a quote that exemplifies what UI design (taken literally as a quote like I would from Shakespeare with none of all the mumbo jumbo of religion):

"So, because you are lukewarm – neither hot nor cold – I am about to spit you out of my mouth. – Revelation 3:16"

So the Squeak UI isn't all that bad. It's different enough that your mind just accepts it as being different. On the other hand, the standard VisualWorks UI for OS X tries to blend in but does it in a way that is just lukewarm... This isn't to say that the Squeak UI or the VisualWorks UI can't be improved on....

In short, I am really impressed by Antony Blakey's efforts. He definitely has some radical ideas for improving (modernizing?) Smalltalk, hence, the title of his blog: "The creation of a new order of things". I will definitely continue to monitor his future work on Smalltalk.

Drag and Drop on Mail Dock Icon

Fri, 30 May 2008 10:29:00 -0700

Programming Quotes, Sayings about Programmers, Software Developers, Application Development:

"The only way for errors to occur in a program is by being put there by the author. No other mechanisms are known. Programs can't acquire bugs by sitting around with other buggy programs. ~Harlan Mills"

The last time I updated to OS X 10.5.2, some developer inserted this extremely annoying bug into Mail-- dragging any file onto its dock icon would crash it! This is particularly annoying because I already had it wired onto my reflexes to perform a drag and drop every time I want to send an attachment to someone.

Eventually I was able to find the solution: change Mail's composing preference to RTF instead of plain text. Well that isn't really a solution since that means that I will have to compose all my e-mails as RTF which is something that I don't agree on. E-mail messages should be plain text whenever possible! RTF might be better than HTML but it is still egregious compared to plain text.

Anyway, I found an alternative solution. Instead of dragging the file to the dock icon, create a new empty message first and then drag the file onto the body of the message. This involves the extra step of creating a new empty message but at least it does not crash Mail nor force me to use RTF. Being able to drag the attachment into the mail message body without crashing it (even with the plain text setting) just illustrates that this is a bug that could have been avoided/fixed since there is nothing inherently wrong underneath with Mail. Instead it's probably just the drag and drop component that needs some reworking.

Yesterday I upgraded to OS X 10.5.3 because I wanted to install the latest iPhone Beta SDK. The README specifically said that OS X 10.5.3 is required.

And I was rather disappointed (but not really surprised) to discover that this Mail bug has not been fixed yet. Fortunately I could use the alternative solution which will suffice until this bug gets fixed (if ever). I'd rather have less features (for instance remove the useless Stationary/Template feature from Mail) than to have a program crashed on the most rudimentary of tasks.

(Finally) Some Good Use for the Camera Phone

Sat, 05 Apr 2008 17:56:00 -0700

I've been reading some mentions/reviews of Evernote on various sites so I decided to try it out for myself. Right now, the latest beta version is by-invitation only. I tried my luck at their invitation-only beta registration and was lucky enough to get an invite the next day. Since then I have sent out 5 (of the 10 invites) to my friends.

The coolest feature of Evernote is its ability to recognize text within images (see this demo video). The ability to recognize text in images is not something new but this is the first time I have seen it offered in a consumer application. Because of this, I finally found a good use for the built-in camera of my iPhone.

Text recognition is not built-in to the application itself. Instead anything that you store in Evernote is synchronized with the Evernote's servers (this allows you access your notes from the web). The text detection/processing is done at the servers and the metadata is sent back to your application. That means that unless you sync with the servers, you can't actually get text recognition. I think this is a good idea since it lets Evernote change its recognition algorithm without bothering the user with some software update.

So how good is the text recognition? I decided to do some experiments and come up with the following observations. These are merely observations so they are not rigorously tested. Also, expect the recognition capabilities to increase over time.

It recognizes some non-standard letters like Intel's old logo on this mouse pad.

It does not recognize vertical text well.

In fact, for vertical text, its recognition seems to be pretty off; recognizing things that are not there.

It probably only recognizes words in the English dictionary since it can't recognize "DTrace".

It recognizes most words but might have some trouble pinpointing their exact location.

I don't think it recognizes symbols well; it's probably optimized for numbers and letters.

It seems to have trouble with multi-colored words like the Google logo.

So for better results, the text should be horizontally written, unicolored and contain only alphabets and numbers. But it works pretty well for most cases. It certainly beats having to enter information by hand.

So, will I continue using Evernote after its beta period? I am expecting that it will require a paid subscription for the ability to sync and recognize text within images but if the price is reasonable, I might continue using it. Moreover, if they decide to create a native iPhone app (an offer it for free for paid subscribers), the likelihood of using it is even higher for me. After all, there isn't a convenient way to sync notes between my iPhone and my computer. I'll definitely keep Yojimbo around though since it handles PDF and has some nice predefined containers for storing image, serial numbers, etc.

External Monitor Setup

Fri, 21 Mar 2008 13:42:00 -0700

After spending about a year with two huge and bulky CRT's in my office, I decided to spend about $700 to get a new 24 inch widescreen display from DELL. It wasn't only the physical size of the CRT but also its blurriness that annoyed me. Here's a picture to show what my desk looked like before:

Both CRTs are Dell M993s. Surprisingly those monitors could display 1600x1200 pixels! However, that comes at the expense of blurriness and eye-ache after a couple of hours.

Here's a picture to show what my desk looks like with the new monitor:

The Dell 2408WFP monitor connects to my MacBook Pro. The other smaller monitor connects to my Windows machine. I share the mouse and keyboard using Synergy.
The smaller monitor is borrowed from my colleague's table since he won't be around until Fall 2008.

Using a large monitor is not without its challenges and problems. The main problem on the Mac (and possibly Windows and Linux) is that it becomes rather troublesome to resize the windows. Here's why: all windows manager that I know have three buttons on each window: close, maximize(expand) and minimize. On a small monitor, clicking the maximize button expands the window to fill your small screen -- usually a desired behavior so you can see more of the contents in the window. On a large monitor, clicking the maximize button, expands the window to fill your large screen -- usually an undesired behavior since you are wasting screen space.

Unfortunately, I have not found a nice way to resize the windows yet. I do have a trick though. Since my external display is powered by a MacBook Pro, I can always move the window over to the MacBook Pro's smaller screen, maximize it and then move it back to the external display! It's cumbersome but it works. And I get uniformly sized windows -- I am rather particular about having my windows be about the same size.

Fortunately things are better with my browser since I can just rely on javascript bookmarklets:

Pimp My Safari: bookmarklets:

"Resize to 1024x768"
javascript:void(window.resizeTo(1024,768))

Updated to Typo5

Thu, 20 Mar 2008 17:37:00 -0700

So I discovered that my web host just upgraded to Rails 2. How did I make the discovery? Well, both my blogs were malfunctioning. And when a rails web application malfunctions, it is usually a good idea to check if they had upgraded it. Previous experience with Typo should have taught me that but sometimes I forget such things.

I should definitely freeze the rails version right now so that I don't encounter such problems in the future.

Anyway, I grabbed the latest version of Typo and installed it. I must say the latest version really looks slick. I chose to use the same Scribbish theme for this blog but there are two new themes that are pretty nice too.

One caveat is that some of the plug-ins have been removed from the base Typo installation. This caused me some problems as I migrated my blog over. I could have just installed the old plug-ins following the instructions from here but I decided to stay fresh. I am not sure whether there is an easier way to do this, but I basically went into the database and remove the sidebars table:
DELETE from sidebars;

I am going to upgrade the softwareengineering.vazexqi.com blog in the next few hours so it should be back up by tonight.

vazexqi.com updated

Sun, 16 Mar 2008 21:36:35 -0700

After delaying for a very long time, I have finally updated the root vazexqi.com site and turned it into something that reflects more of what I am doing as a Ph.D. student. I was only compelled to do it because the CS department demanded a curriculum vitae from each of its students. I wanted to put a web address on my CV so that people can keep up with what I am doing and find. However, I did not feel that it was appropriate to put my blog address directly on it; after all, a website that starts with the word "blog" might not sound professional enough to some academic peers (it should be fine for a developer's blog though).

I was too lazy to actually write everything from scratch so I decided to give RapidWeaver a try. I had used it before for various tasks but I am only needed to use the demo version since I would just borrow (and credit) their templates and then code everything up by hand. But this time, I decided that since vazexqi.com was going to be mostly static content, I needed a convenient way to easily update it using some application. Also, I am not really a web designer so I would like to be able to quickly change the template without having to do too much work on my part.

Overall, I think the new look is pretty decent. There are things that still need updating but overall it's a good start. There are two things now that I must remember to do: constantly update the static pages and upload a picture of myself to the front page....

I don't really subscribe to the idea of putting yourself out there on the web for everyone (like this guy) but I do think that it is important to have a clean web page where your peers can easily find you.

Thoughts on the iPhone SDK

Mon, 10 Mar 2008 20:07:00 -0700

As I am writing this, I am also partly listening to the Apple March 6 Event where the iPhone SDK was first introduced. And halfway through, I cannot help but notice that Scott Forstall was practically emulating Steve Jobs. He even used phrases like "... a screamer...", "... we made it even better...", "... the iPhone is the most advanced... ", "... years ahead of any other...". He is definitely a smart guy but I think he is emulating Steve too much. It would have been nice to see his own personality. On the other hand, this also means that I probably have watched too much of Steve Jobs to know how he talks....

So, I downloaded the free version of the iPhone SDK. It comes in at a whopping 2.1 GB so it took about 20 minutes to download.

After extracting it, the README has this to say:

It requires about 5.3 GB for installation.
It requires OS X 10.5.2 on intel machines (some claim that it can work on powerpc as well).

There is the option to keep Xcode 3.0 and Xcode 3.1 Beta that comes with the iPhone SDK on the same machine. I did not choose this option so it replaced my original developers tools (meaning that I did not need to sacrifice extra disk space at the expense of a possibly buggy beta version Xcode 3.1).

I tried some of the sample apps from the iPhone developer site (it uses a generic URL of http://developer.apple.com/iphone/samples/index.action which checks to see if you are authenticated).

Here are the ones that I tried:

Kalimba - Supposed to be a replica of an African thumb piano. We should be able to strike each bar and have a musical note sound. It failed miserably on the iPhone simulator -- sound will not play and the piano refused to rotate to landscape mode. See this thread. Here's a picture to show what I mean:

This is one of the examples for the iPhone SDK. Unfortunately, it does not seem to work properly on the simulator – sound doesn't work and it refuses to rotate into landscape mode.

Jigsaw - Just a simple jigsaw puzzle. Works fine.

TheElements - Shows the periodic table with the possibility to view each element's page on wikipedia. When I clicked on the link to wikipedia, the simulator crashed gloriously -- no warnings, no output to console. It just crashed. After some playing around, I discovered that it crashes when you run it immediately after it opens up in the emulator. Instead, if you go to the home screen and then activate TheElements application, then opening a link would work!

GLGravity - Draws the canonical OpenGL teapot and allows you to rotate it by rotating and tilting your iPhone. This refused to run on the simulator -- claiming that it needs to run on an iPhone.

I have to agree that the iPhone SDK has a lot to offer. If you don't believe me, just watch the video. The demo comes on at about 30 minutes through. It's akin to writing for a mini version of OS X with the addition of an impressive user interface, multi-touch control and internal accelerometers. Games will definitely benefit from this. So it should be easy for most developers to get started once they familiarize themselves with the new human interface guidelines.

Spore on the iPhone. It uses the accelerometer on the iPhone for controls.

However, as impressive as the SDK is, it also has some shortcomings which can't be ignored. Here's why (some of these might change when iPhone 2.0 debuts but I doubt it):

No garbage collection.
Creating an iPhone Application:
Note: iPhone OS does not support memory management using the garbage collection feature that is in Mac OS X v10.5 and later.
Maybe most Objective-C developers love doing manual reference counting but this seems like something that should be addressed. After all, Google's Android platform supports this. Moreover, Objective-C 2.0 already supports it so garbage collection could have been enabled from the beginning.

Some might argue that garbage collection adds extra performance overhead. But consider what happens when your app starts leaking memory all over the place. And with all the rich history that garbage collection has, it's really amazing that companies don't really start to take it seriously.

In fact, during the video, they showcased several different developers creating fantastic prototypes for the iPhone in two weeks. I suspect that development and debugging time could have been reduced more if only garbage collection was enabled. =)

Crippled simulator
Not sure if this will change in the future but the current simulator is rather dumb and featureless. You cannot even trigger the hard buttons (like the volume UP/DOWN, silencer, top button). The only button you can activate is the home button -- the one at the bottom of the screen. And no, you can't simulate the features of the accelerometer.

It does however support the two-finger gesture if you hold on the OPTION key on your keyboard.

I suspect that this is a ploy by Apple to get people to i) buy iPhones to test on b) subscribe to the $99/year developer deal to get your app on to the iPhone. After all, how are you going to test your next greatest app that relies on the accelerometer if the simulator cannot even handle it. However, of my three criticisms, this might be the easiest one to fix.

Google's Android emulator is currently better but that could be because there isn't an actual phone to run it on yet!

$99/year (yes, it's PER YEAR!)
Apple Announces iPhone 2.0 Software Beta
During the beta iPhone SDK program, a limited number of developers will be accepted into Apple’s new iPhone Developer Program and offered the ability to get code onto iPhones for testing. The Standard Program costs $99 (US) per year and gives members an iPhone SDK and development tools; access to pre-release iPhone software; technical support; the ability to get code onto iPhones for testing; and distribution of applications via the new App Store. The Enterprise Program costs $299 (US) per year.

To even get your app for testing onto the iPhone you need the special version of the SDK or a special license. This is weird since that means that I cannot even write an app for MYSELF and install it on my phone just for my own PERSONAL use.

Plus, right now no one can install your app unless you list it on iTunes (which minimally also requires the $99/year contract).

You can argue that this annual fee is not really a problem with the SDK but I think it is. After all, without paying the fee, your SDK basically allows you only to experiment and not actually get anything onto your iPhone.

I think the $99/year (or $299 for Enterprise) fee is somehow used to do code signing which I think is a weird way to guarantee that your program is non-malicious. I could be wrong.

Also, after having to pay $99 would anyone release your app for free??!! I look forward to seeing how many free apps there will be. My prediction is that apps that are somehow tied to a desktop app that costs money (for instance, Transmit, NetNewswire, etc) might be free since the cost is absorbed by the desktop app.

It would be interesting to see how it would compete with Android in terms of interested developers. I am not sure if it is a good idea to actually get developers to pay to actually use the development tools.

I do like the idea of paying the yearly fee to have Apple list your product for you on iTunes but it would be good to offer developers the choice of distributing their own applications if they want. In fact, just being able to install your own app on your own phone would be fantastic!

So while the SDK definitely has a lot to offer, it also has some serious shortcomings that might discourage some developers. But with all things Apple, they certainly won't mind ostracizing some developers in favor of others....

Alan Kay's Talk at TED

Mon, 10 Mar 2008 09:14:00 -0700

There are certain events that are just so exciting that I feel compelled to blog about them immediately after I experience it. This is one such event.

Alan Kay recently gave at talk at TED. You can view his video from here. Like all TED talks, it's about 20 minutes long so it's short and straight to the point. The rest of my post will make references to the video, so reading it without watching the video might not make much sense.

Unsurprisingly, in the video, Kay demonstrated the canonical moving car example for Etoys. The moving car demo is something that most people familiar with Squeak would have seen. It's really simple but it lets kids experience programming in a fun interactive way. Unfortunately, this is something that most modern languages have failed to enable. After all, which is more fun: printing text to the screen or watching your creation actually move on screen?

However, the second part of Kay's demo was even more interesting. He shows what you can do to help illustrate some simple math and physics properties in an insightful manner. It uses all the features of Etoys (or maybe the full Squeak implementation) to let students experiment by themselves.

Experimenting with this would have been so much cleaner than using a tape meter. It's actually even cooler when you watch the animation or code it up yourself in Etoys.

For instance (and this was something that impressed me), you could design a simple car that drop dots along as it moved. So, a car that is accelerating will be dropping dots further and further apart from one another. This is basically the same idea as using a tape meter. However, the animation of the car moving and dropping dots seem so much cleaner to me. You can easily illustrate the concept of velocity and acceleration without having to talk about friction, etc. Something that is unavoidable with a real experiment. This helps especially when you are teaching a younger audience about the basic principles of motion.

Toward the end of the talk Kay showed an example running on the OLPC. So I was curious whether all courseware on the OLPC will be interactive or whether they will be like normal textbooks only in digital format. Either way, it's already hard enough to actually get good content onto the OLPC. As far as I know, there is no group dedicated to creating content for the OLPC yet.

However, I was able to find a couple of interactive learning environments at OLPC Courseware Review but, from the list, it seems that Dr. Geo II is the only one that has been ported to run on the OLPC. It would be interesting to see if there is a Google Summer of Code project for creating/porting an existing interactive learning environment to the OLPC.

Incidentally I was reading "A Mathematician's Lament" by Paul Lockhart which also talks about how to revamp the current K-12 mathematics education. The paper is available from here. Basically, Lockhart says that there is not enough experimentation with math going on in the class rooms. And that most of math is rote memorization with little appreciation for the beauty of math.

The math education back in Malaysia is not much better either. In school, the teachers are more interested in finishing the syllabus. So students either get-it in school or have to rely on paid tutors to teach it to them. There's very little appreciation on the derivation of the proofs of math. Either the derivation is skipped entirely while teaching or it follows the route of the boring derivation on the board that doesn't engage students.

PhD Qualifying Exam

Fri, 07 Mar 2008 13:08:12 -0800

So every student doing a PhD at UIUC (and I think any US university) is expected to pass a qualifying exam. The qualifying exam gauges whether a student is competent enough to continue in the PhD program. However, it's much more than that. I think it's more of a test to see how well you can do a presentation and answer tough questions during the presentation; as well as trying to not sound stupid in front of a very smart audience.

Anyway, I took my exam two weeks ago. It was an oral presentation where I was assigned two papers: The jastadd Extensible Java Compiler and Automatic Test Factoring. Both papers were about tools (something that I interested in as I mentioned in my research statement to the exam committee).

It's interesting to note how the two papers are somehow connected with me. I first saw the JastAdd system while I was at OOPSLA '07. I had even talked to the authors of the paper, attended their poster session and even their demo session. Fortunately (or unfortunately) I did not attend their presentation session so my presentation was not influenced by theirs. I was already interested in studying this paper in-depth because of the system. And having it chosen as my qualifying exam paper gave me even more motivation.

The second paper was interesting because, Danny, one of my colleagues from the same research group is now working under Prof. Michael Ernst. Danny had referenced some of Ernst's work before. So I was familiar with some of the terminology in the paper and was able to use that to my advantage.

It's just interesting to see what a small world it is....

My slides for the presentations are available here: JastAdd.pdf and AutoFactoring.pdf. I am not sure how interesting they would be on their own but they are pretty to look at.

And I just found out that I passed! The committee had this to say:

"The committee were impressed with his performance and background knowledge".

So that's one crucial step toward completing my Ph.D! :)

Rubber Bands

Fri, 29 Feb 2008 18:40:31 -0800

My girlfriend and I decided to join the Innovation Tournament Video Contest. The video above is our submission. It could definitely be improved. However, considering the fact that we are only a two-person team and that the weather here is less than conducive, I think we did OK. Overall, it was an interesting experience -- something that I normally would not have done.

Update: Well, turns out that we won! We get to have breakfast with Henry Petroski, an author whose books I enjoy and a visit to IDEO. I wasn't aware of this before but turns out that Henry Petroski did his Ph.D from UIUC! My advisor, Ralph Johnson and my colleague, Maurice are both fans of his writing. It is great to be able to meet Mr. Petroski in-person!

The prizes were sort of interesting because there were slightly more prizes than participants. So this means that a) everyone who participated was really a prize-winner and b) each team got to choose more than one prize. Some prizes, like the opportunity to attend breakfast with Mr. Petroski, were not limited or exclusive so multiple teams could choose the same prize.

Session restore (sort of) in Eclipse with Mylyn

Sat, 02 Feb 2008 14:59:00 -0800

This was something that I really wanted to blog about for a long time...

Last year I wanted to know a way to save sessions in Eclipse like I could for Firefox. For instance, Firefox allows you to save the open tabs and windows into a new session and restore that session in the future. That way if you ever need to recall a set of tabs for reference, they can be easily activated by restoring the saved session.

In fact, any decent, editor or IDE should the option to save sessions. Heck, Vim and Emacs have this feature out-of-the-box. Sessions are really useful when you have to work on groups of related files at the same time but don't want to have to remember which they are.

So why was there apparently no way to do this in Eclipse? Initially, I thought that Working Sets might be the solution. However, they only allowed you to group files into sets. They don't actually remember the editors that are opened and what state you were in. So Working Sets were not even a poor man's implementation of sessions.

Then epiphany struck! We could use the Mylyn plug-in to accomplish this. In fact, as you shall see, Mylyn can do even better than just saving sessions - it infers them automatically based on what you are doing! Mylyn comes installed standard now on Eclipse 3.3 and higher. In fact, the Mylyn view is even shown by default; it's not activated though.

Anyone who does not use sessions has a) an incredible memory, b) an inhumane ability to do context switching between tasks AND c) the luxury of not having to close his IDE ever. Or the developer just doesn't know that such an excellent tool exists out there...

This is Mylyn
I have readjusted my perspective a bit so that everything can fit nicely in a 800x600 window. The picture above shows the Mylyn view with some sample local tasks.

Activating a previous session
I am activating a previous session. By default, Mylyn automatically remembers the last context that you were in before closing the editor and will restore that.

Previous session restored
You can see that Mylyn remembers the files that were opened in that session and has restored them in the editors. *The current active task (see the Task List view) has a blue bullet next to it. In the Package Explorer view, you can even see the other files that I might have referred to in a previous session but did not open in any editor.

Creating a new local task (context)
Mylyn allows you to create local task for your own use. With the proper server, you can also create sharable tasks in a Bugzilla or JIRA repository. That way, you can share the same session with yourself when you are working on a different machine or with your other teammates so that they can take a look at the same things that you are looking at.

Editing a local task (context)
You can easily associate other metadata with each task. In fact, Mylyn was originally created to be a task-oriented system. It allows you to split your work into little tasks to help you focus.

Deciding to show everything or just the active task
You can easily switch between showing all the files in the Package Explorer or focusing on the active task by clicking on the Mylyn button.

Mylyn has a whole bunch of other features. Some of the interesting ones include:

The ability to share a context with different tasks. You can clone the current context and paste it into a different task.
It cleverly remembers what editors and files that you have accessed and stores those into its session.
It intelligently forgets editors and files that you have not looked at for extended periods.
You are always in control - you can override the behavior easily and promote/demote certain files from sessions.
It records how long you spent on each task so that you can actually report that figure with certainty.
It's well integrated with different perspective and views in Eclipse. And it is constantly being improved upon.

Mylyn is great for helping you focus on your programming tasks. It stays out of your way for the most part but is easily accessible when you need it. Once you start using it, you really wished that every IDE out there (including the venerable IntelliJ) supported it.

Why tools can make it a pleasure to learn a new framework

Tue, 15 Jan 2008 11:23:08 -0800

I was reading the book Spring In Action in my attempt to learn about Spring. More importantly, I needed to know enough to be able to incorporate refactoring support for it as part of my project.

Unfortunately, the book had some typos which were actually technical errors. And this was just in Chapter 1! If you are trying to learn something for the first time and there are typos, you might not be able to detect it. And this can lead to hours of frustration....

Fortunately, IntelliJ has support Spring. And it detects the errors for you! So even if the technical reviewers did not detect the error, at least your IDE (a good one) can do it for you and save you time.

IntelliJ 7 has support for Spring. In this case, it detected that something was wrong with the xml configuration file.

It even offers the ability to correct the error!

I wonder if the error in the book could have been detected had the reviewers use a better tool. Or at least attempt to run it using some automated tool.

Leave No Stone Unturned

Mon, 07 Jan 2008 15:55:00 -0800

I spent the previous week reading two very interesting - and some might say controversial - books. The titles of the books speak for themselves. However, that is not the main reason for this post. Instead, this post is about what I think is an important point of both books; something that might be hidden underneath both the hype and criticism surrounding the books.

Both books advocate the need to question everything -- even religion. Religion has always been considered a taboo subject and its veracity has always been taken for granted. More often than not, religions rely on a divine book that has been perpetuated by a deity as the source of truth. And this source of truth, according to its followers, shall not be questioned. This is faith.

And that is where a potential problem lies. While I am certain that both authors have tried their best to verify what they have written, they are not ashamed or adamant about making corrections to their books when the evidence shows otherwise. With sufficient evidence, both authors might even be converted toward religion. I doubt the same could be said about religious texts. Religious texts might have been perpetuated by a divine deity, but they are still transcribed by human beings.

Now, it might very well be that religious texts are indeed infallible. However, without testing, without questioning, we can never be sure. At least, we cannot be sure without just relying on blind faith alone. To put this into perspective, most people are not going to sit in a plane after being told that it is powered through sheer faith-power alone.

If anyone doubts the need to question, just look around us. All modern inventions come about through some form of questioning. If we just accepted everything as being magical then we would never have many of the inventions that we take for granted today. The scientific theories that we have today might not be complete but they sure do a fine job of making our lives better. And those theories are continuously being subjected to testing and questioning to refine them: obsolete ones are rejected, replaced or even removed.

Religion might be true; it might be false. Religion might be necessary; it might be unnecessary. But like everything else, it should be investigated and questioned. And every individual should be free to draw his or her own conclusion based on the evidence and not just on the words of influential figures. It goes the other way around too. Just because the authors of both books claim something, it does not mean that it is true. Again, the facts and evidence must be evaluated.

For many religious devotees the veracity of religion is not necessarily an issue. And that is fine. However, for some other people, the quest for verifying the truth is important. They should be granted the freedom to question such things and make their own decision without any backlash from members of religious communities. Both books present examples of reactions from religious communities on this issue of seeking the truth. Some reactions being more harmful than others.

And what happens when the truth is discovered? Probably nothing much. People are still free to choose whether or not to believe in religion. Neither author strongly suggest the need for getting rid of religion. What they do is merely present their ideas and the evidence to support it. But they never force anyone to abandon their beliefs.

Zen and the Art of (Pair) Programming

Sun, 23 Dec 2007 18:50:43 -0800

Since this book is so general, it can be interpreted in many different ways. I choose to interpret some of the advice it offers in terms of programming.

Programming is an intellectual activity. It takes sufficient intellect, great concentration and lots of patience. And there are some things that can easily sap a programmer's concentration and patience. Robert Pirsig, author of Zen and the Art of Motorcycle Maintenance uses the term gumption as a reference to the gasoline that motivates a person to continue working on what he needs to get done. And he calls the little things that retard the progress of work gumption traps.

Anyone who has done programming before is certainly aware of some gumption traps. When your IDE that has been working fine for the whole day suddenly starts throwing peculiar errors and exceptions, you feel infuriated. Or when you try to chase down a bug that prevents your program from working only to discover that you had somehow used a stale version of the source file and that the bug had already been fixed. It is not the encounter with these incidents that causes you to lose your zen as you are programming; rather it is your reaction to these incidents that cause the state of zen to be broken.

An anecdote would illustrate this better. Pirsig uses the South Indian Monkey Trap parable to illustrate this:

The "South Indian Monkey Trap" was developed by villagers to catch the ever-present and numerous small monkeys in that part of the world. It involves a hollowed-out coconut chained to a stake. The coconut has some rice inside which can be seen through a small hole. The hole is just big enough so that the monkey can put his hand in, but too small for his fist to come out after he has grabbed the rice.

Tempted by the rice, the monkey reaches in and is suddenly trapped. He is not able to see that it is his own fist that traps him, his own desire for the rice. He rigidly holds on to the rice, because he values it. He cannot let go and by doing so retain his freedom. So the trap works and the villagers capture him.

The normal reaction a programmer has for a gumption trap is to lash out and probably try to find the solution fast. However, like the case of the monkey trap, sometimes even when the solution is apparently within your grasp, you tend to forget that there could be a different solution. It takes a great amount of brain power (to use the cliche term) to perform a paradigm shift and try a different route even if the end goal is within your grasp.

As a concrete example, think of how many times you had fixed a bug only to realize that it was but a tiny manifestation of a bigger bug? Or that the bug that you are seeing could be a transient one that exhibits itself every 500 hours and that it would be better to provide some tolerance for it rather than trying to fix it?

Look one way and you see a duck. Look another way and you see a rabbit. Different ways of looking at the same thing requires a paradigm shift. And programmers need to be able to do this numerous times each day.

This idea of taking a step back from what you are doing to actually think about your actions is also highlighted in Edward De Bono's Six Thinking Hats. De Bono proposes six different colored hats: white, red, black, yellow, green and blue. The blue hat captures this notion that you need to be cognizant of the bigger picture and how to react accordingly.

Which brings me to my point: pair programming might help alleviate some of the gumption traps. After all, it is rather unlikely that two programmers with completely different mind sets would fall into the same trap at the same time. Having someone watch over your shoulders does prevent some rather embarrassing episodes of barking up the wrong tree since you now need to convince your partner to do the same.

Even if you do not have the luxury of having someone to pair program with, you can easily just keep a log of all the tiny mistakes or observations that you have encountered during your programming sprint. It's those moments of "a-ha" that seasoned programmers reflect upon to give them the edge over the newbies.

You can find more information about gumption from Chapter 26 of the book. It's a book that has continuation from chapter to chapter but you can easily grasp the advice that Pirsig dispenses by reading each chapter independently. Like I mentioned in the beginning, the book is general enough that you can interpret it differently and mould it to fit various situations.