Angelo's Stuff

Lazy Programming

2012-02-02T15:29:00.005+05:30

I am a slightly lazy programmer. There I said it! This doesn't necessarily mean that it's a bad thing to be lazy... Lazy programmers try to avoid doing grunt work. They are the ones who will write that tiny tool or that simple script just so they can get out of having to do a repetitive task. Those same utilities will end up being used by others and will in the long run boost productivity!

"So, is it good to be lazy?" - one might ask. The answer is - "It entirely depends...". You see, a lazy programmer can also be that fellow most people find uncooperative in a team. He might want to spend two whole days (at crunch time!) writing a script that would save him a few hours of continuous grunt work. If a lazy programmer is forced into a position where automating a task is quite infeasible, then BEWARE! The programmer will now unleash the beast within - moaning, groaning and cursing all the way through to task completion. Another area where lazy programmers don't fit in, is when they are called upon to debug someone else's code. Most programmers hate this part of the job but lazy programmers hate it even more! They will naturally point out flaws in the code architecture (ritually quoting design patterns that should have been used).

However, there is one very important thing that lazy programmers love to do! Lazy programmers love to design code. Give them a chance to do so and they will build you a very flexible and generic system (covering lots and lots of use-cases). The same system could be taken and simply "plugged" into other projects with similar requirements! Lazy programmers also tend to write very elegant code with fewer bugs by virtue of the fact that they encourage re-usability.

At the end of the day, Lazy programmers are bad soldiers but good Generals. Are you a lazy programmer? Let me know what you think constitutes a lazy programmer in the comments.

Happy (lazy) coding!

(Above comic, courtesy of http://xkcd.com)

Create an icy glass silhouette with Gimp.

2012-01-05T18:03:00.034+05:30

Hey folks!

I came up with a nice effect which I thought was really worth sharing. Refer to the following image for a clear picture (pun intended) of what we are trying to achieve.

Note that I am using Gimp 2.6.1 on Windows. Gimp is free software and can be downloaded from www.gimp.org. Since I don't want to end up with an extremely long-winded post, I'll just assume that you can find your way around Gimp. If you do find yourself stuck at some point, feel free to comment on this post and I will gladly help you along.

Step 1: Begin with an empty canvas size of 640 x 480.

Step 2: Set the foreground color palette to the following shade of Blue - 80c0ff and bucket fill the background layer.

Step 3: Create a new background layer and name it 'Noise'. Bucket fill this layer with the following shade of Blue: 386597.

Step 4: Go to Filters->Noise->Hurl and use the settings in the image below.

Step 5: Go to Filters->Blur->Gaussian Blur and apply horizontal and vertical blur radius of 25.

Step 6: Set the opacity of the Noise layer to 70 and the blend mode to Value. Your image at this point should look similar to this.

Step 7. Now, create a new layer with a white background. Go to Filters->Noise->RGB Noise and use settings of 0.2 for Red, 0.2 for Green, 0.2 for Blue and 0.0 for Alpha.

Step 8: Set the opacity of the White layer to 30 and the blend mode to Grain Extract.

Step 9: Create a new transparent layer on top. Name it 'Silhouette'.

Step 10: Set the foreground color to full white and paint haphazardly inside this layer. See the picture below for the kind of painting you should do.

A real piece of art, huh? You don't need to precisely follow this painting but try to concentrate on the center of the picture since that is where we will ultimately end up placing our silhouette.

Step 11: Gaussian blur the layer with horizontal and vertical blur radius of 100. Change the blend mode of the layer to Value. Your image should now look similar to this.

Step 12: Now, its time for us to put in our silhouette! Make a heart shaped cut-out in the center of the 'Silhouette' layer. You can easily make the top part of the heart with two circles and then use the free select tool for the bottom portion of the heart. Then just delete the area within the selection. Alternatively, you can use the eraser tool and erase in the shape of a heart. No need to be totally meticulous about the shape of the silhouette since we will be blurring it anyway. I've chosen to go with the selection method and if you did the same, you should end up with an image similar to the one below.

Step 13: Select the entire 'Silhouette' layer (Ctrl + A) and Gaussian Blur it with horizontal and vertical radius of 30.

Step 14: There is no Step 15!

Here is another variant of the effect. I just played with the colors, opacities and of course did a completely new silhouette.

Enjoy!

Create a simple vintage photo effect with Gimp

2011-12-31T10:47:00.021+05:30

Hey folks!

Sometimes you might want to take a recent photo and make it look like it was taken with a vintage camera. Here's one easy way to do this. Note that the image processing software that I am using here is Gimp 2.6.1. Gimp is free software and can be downloaded from http://www.gimp.org/

Alright, just to give you guys a feel of what we're trying to accomplish, here are before and after shots of a photo that I took when visiting the Chinese Gardens in Singapore.

Before:

After:

Step 1: Open the image of your choice in Gimp.

Step 2: Duplicate the image layer one time. You can duplicate a layer by clicking on the duplicate button at the bottom of the layers panel window or pressing Shift + Ctrl + D (in Windows).

Step 3: With the new layer selected, go to Colors->Desaturate. Pick 'Luminosity' among the options presented and then click OK. Your image should now look Black and White.

Step 4: Change the blend mode of the Black and White Layer to 'Overlay'. The blend mode can be changed from the drop-down menu at the top of the Layers panel.

Step 5: Change the foreground color to the following shade of Yellow: fbf2a3

Step 6: Go to Layer->New Layer (or press Shift + Ctrl + N). Among the Layer Fill type options, select 'Foreground color'. Leave everything else as is and click OK.

Step 7: Change the blend mode of the new layer to 'Multiply' and set its Opacity to 60. Your image should now have a yellowish tinge.

Step 8: Change the foreground color to the following shade of Magenta: e865b3. Once again, add a new layer with Layer Fill type as 'Foreground color'. Change the blend mode of the new layer to 'Screen' and set its Opacity to 20.

Step 9: Change the foreground color to the following shade of Blue: 0949e9. Again, add a new layer with Layer Fill type as 'Foreground color'. Change the blend mode of the new layer to 'Screen' and set its Opacity to 17.

Step 10: That's it! We're done. You may tweak the opacities of the Yellow, Magenta and Blue layers to make your particular image seem more authentic.

Enjoy!

Light Snake for HTML5!

2011-12-30T13:27:00.006+05:30

I have had the good fortune to explore a bit of HTML5, an emerging web standard that is poised to take the online world by storm. The technology isn't quite there yet. Current browser vendors offer differing or incomplete implementations of the standard and it's a bit of a pain to ensure that whatever you write works generically. Still, this is one of those lemons that bears watching...

The first thing that crossed my mind was to port LightSnake. Its a simple and fun game of snake and requires very minimal player input. And so, I did manage to port the game from C++ to Javascript and get it running acceptably well on most of the major browsers. One notable exception is that dinosaur of all browsers, the one that exists simply to torment all web-developers. Yes, Internet Explorer!

The project has been hosted on Google App Engine and can be accessed from the following URL: lightsnakegame.appspot.com (I wanted to get the app name 'lightsnake', but someone seems to be squatting on it).

Enjoy!

Light Snake

2011-11-09T20:50:00.004+05:30

While listening to some really cool music on soundcloud, an image of the old-school Snake game popped up in my head. A game of Snake with neon lights. So, I thought to myself - "Heck, I should make this!" And so I did...

Needless to say, I didn't sleep that night.

Want to play? Get it from:

1. My Microsoft Skydrive

2. indiePub Games

How to erase specific elements from an STL container - the C++ way.

2011-10-27T20:56:00.008+05:30

STL iterators are tricky little fellows. One moment they act clean and the very next, they throw their hands up and say something cryptic. Consider this snippet that erases all elements whose values are 20 from a vector of integers.


typedef std::vector<int> IntVectorType;
IntVectorType vInt;

for(IntVectorType::const_iterator iter = vInt.begin();
iter != vInt.end(); ++iter)
{
 if( *iter == 20 )
 {
     vInt.erase(iter);
 }
}

Lo and behold! The program crashes! This is because when you erase an element from a container all iterators to its position are invalidated. This just happens to be our loop iterator. So, what is an innocent programmer to do?

Well, there are two ways to erase individual elements in an STL container.

Method 1: The crude way ( recommended for cavemen/barbarians/C -programmers ;) )


IntVectorType::iterator iter = vInt.begin();
while(iter != vInt.end())
{
 if( *iter == 20 )
 {
     iter = vInt.erase(iter);  // Get iterator to next element.
 }
 else
 {
     ++iter;  // Increment if not erased.
 }
}

The method vector::erase() returns an iterator to the element that subsequently follows the last element that was erased. So, we just use that iterator to continue looping. Good! Problem solved! Is there a better way?

Method 2: The modern C++ way (recommended for rockstars/you/me)


struct EraseFromVector
{
    // Functor
    bool operator ()(const int value) const
    {
        return (value == 20);       
    }
};

vInt.erase(std::remove_if(vInt.begin(), vInt.end(), EraseFromVector()), vInt.end());

Looks like g(r)eek, you say? Alright then, let me explain. Basically, std::remove_if() is a magical chap. He takes two iterators as a range within which to work. For each element within that range, he then checks the unary predicate(our third argument) to see whether the element should be removed or not. If the predicate returns true, the element is removed.

I did say "removed" but in actuality, remove_if() sends the doomed elements to the back of the container. He doesn't actually remove them. How could he? He doesn't know what kind of container he's working with. Only the container can remove elements.

The nice thing about remove_if() is that he is guaranteed by the standard to preserve the order of the elements that were not removed. So, if our vector contained the elements 10, 20, 30, 20, 40 in that order, it will now contain the elements 10, 30, 40, 20, 20.

Finally, remove_if() returns an iterator to the start of the sequence containing all those miserable elements just sitting there at the back waiting for the axe to fall. We pass this iterator as the first argument to vector::erase() and an iterator to the end of the vector as the second argument. In one full swoop, all elements in the range are erased.

Now, doesn't this seem a lot more fun than a boring old while loop? :)

R.I.P Steve Jobs

2011-10-08T09:40:00.006+05:30

At first, the world saw him as nothing more than a nerd, a high school drop out, a rebellious kid. Then the world saw him as a geek, a competitor, an irrational human. Being fired from Apple was the best thing that could have happened because that's what made him a real entrepreneur.

A man who looked at the potential in smaller companies and brought out the best in them. He believed in beauty and elegance in computers unlike the rest of the world. The world resisted his ideology but never killed it.

He returned and changed the music industry for the better. He went through a near-death experience. He beat it, came back and changed the entire way we perceived a digital world with the release of the iPhone. Now, the world sees him in a different light - Visionary, Creator, Future Technologist.

Requiem De Pace - Steve Jobs. You will sorely be missed.

ACSVParser: A simple CSV parser writtten in standard C++.

2011-09-08T21:55:00.001+05:30

Hey folks,
Its been a while since I posted back here... ok, its been a looong while. A lot has been going on. I've pushed forth my career in gaming all the way to Singapore! Yes, that's one of the four asian tigers and it sure is one of the best places to be working as a game developer. That, of course, does not mean I will let this blog lie fallow. So here goes...

One of the most interesting (vexing?) things about programming is that some of the simplest things turn out to be not so simple at all! Consider a CSV reader. We've probably used one (if not written one of our own) and yet we all know that it could do with a whole lot of customization. Some of the general peeves, I've heard are:
"I don't want to use commas, I like using the caret symbol!"
"Why can't I have new lines in my CSV content?"
"I want to have embedded spaces in my CSV data!"
"I want to sneeze with my eyes open, darn it!"

All of these (except the last one), led me to stop kicking the can down the road and come up with my own parser. I called it ACSVParser(after yours truly :))

The project is hosted on github at https://github.com/angelorohit/ACSVParser
Do check it out and let me know what you think (feedback, suggestions, issues).

Cheers!

Poem - The Warning

2011-05-20T09:23:00.003+05:30

While going through an old diary of mine, I happened to stumble upon a poem I'd written in high school. It made me remember that I did want to be a writer before I became a programmer. Perhaps someday, I'll be able to do both.

The Warning

Spare me your protests for peace and love,
You do nothing but put on a lively show…
For then you disbelieve the one above,
And meekly forsake the man next door.

If autumn leaves were to fall in spring time,
Or Snowy flakes were to cover a summer street,
You would still call this poem a crime,
You would still throw tantrums and stamp your feet.

Your hunger-strikes won’t get what you want,
This isn’t the way the battle should be won,
I see starved looks on faces gaunt,
But is what you demand inevitably done?

The bomb blasts you decry aren’t one of a kind,
Hold on a bit and press rewind,
This happened before but you didn’t mind,
Now why would you get that petition signed?

Please don’t belittle this poem of mine,
I’d really appreciate it if you spent the time,
To work through each and every line,
You’ll see there’s always a reason and rhyme.

How to install a game in 12 easy steps

2011-04-16T21:40:00.005+05:30

Hey folks,

Its been quite a while since I posted back here but let it not be said that this blog is dead! I really wanted to share my experience installing Batman Arkham Asylum - Game of the Year Edition. I purchased the game from a popular digital distribution platform - Steam. The payment process was real simple and downloading the game was equally so. The problem came when I wanted to actually install it. And so began a grand adventure to get the game up and running.

Step 1: I Put in the activation code for the game. Straight forward enough.

Step 2: Game happily launches.

Step 3: Game tells me that it requires "Games for Windows - LIVE" (loving called gfwl). I am also told that if I choose not to sign up with a Windows Live account, the game will let me play but NO SAVING!

Step 4: Everybody needs to save their game progress, right? So, I go sign up for a Windows Live account (am I ever going to use that anywhere else?).

Step 5: The same activation code mentioned in Step 1 is required for gfwl. Alright, done and dusted...

Step 6: Now, I am informed that there is an update for gfwl! WHOOPEE! I love downloading updates.

Step 7: My insanely slow internet connection forces me to wait another 20 mins for the update to complete except... SWEET MOMMAYAMA! It never completes..

Step 8: I quit the game and start over, all the while praying to the Norse Gods of Asgard for some hope of salvation. Still no go.

Step 9: I go online and google something retarded like "Cannot update Games for Windows Live".

Step 10: Everyone seems to be having a host of problems each one unique from the rest. I realize that I need to just download and install the darn gfwl service directly. I twiddle my thumbs as my crawling internet connection further keeps me limbo about my fate.

Step 11: Sweet Mana from heaven! The service is installed. It now tells me there is a hotfix for Windows XP. Alright, I'm down with that. The hotfix was likely the issue that caused all hell to break loose n Step 7 anway.

Step 12: Finally! I am allowed to play the game like any normal paying customer should.

The game is simply wonderful! Batman is uber-cool, the Joker is a real gag and Comissioner Gordon looks like Mr. Universe in formals. I'm now enjoying playing the game but I still wonder if I ever needed to go through all that pain just to install the darn game!

Happy New Year!

2010-12-31T11:18:00.008+05:30

Happy 2011 everyone! Have a wonderful year ahead!

" Ring out the old, ring in the new,

Ring, happy bells, across the snow;

The year is going, let him go;

Ring out the false, ring in the true. "

~ Alfred Tennyson, 1850

(1600 x 1200 Designed with Gimp 2.6.1)

Game Review: NinJump for the iPhone.

2010-09-24T21:14:00.008+05:30

NinJump from Backflip Studios is one of those games that captures your attention from the get go due to its lovely visuals and simple gameplay. Our protagonist is a Ninja with an uncanny ability to defy gravity and run up walls. Of course, being a Ninja you also get to deal with all manner of enemies ranging from cute little twitter blue birds, squirrels and rival clan Ninjas. Your wall-running quest ends when an enemy manages to tag you. Gameplay goes in short bursts hardly lasting more than 5 minutes at a stretch before you run into an enemy and lose. The game is free to download from the AppStore but includes ads. If you find the ads particularly annoying, you can disable them via an In-App purchase.

Basic Mechanics:

There are two walls on either side of the screen held in portrait mode and you can bound from wall to wall by simply tapping the screen. When jumping from one wall to the other, the Ninja does a slicing action with his Katana (sword), rending anything that gets in his way. Timing is key. The jumps must be timed so that you slice through your enemies. If you knock into an enemy while running up the wall, its game over.

Power-ups:

The game isn't as bland as a simple run and slash. There are god-awesome powers too! If you manage to kill three enemies of the same type one after the other, you gain a power-boost that is specific to the enemy that was killed. For instance, if you manage to kill three blue birds in a row, the character will sprout wings and take to the air, smiting anything that gets in his way. After a short while, the power will end and you will become your usual vulnerable self again. The power-ups are particularly visually appealing and when you see them for the first time, you are bound to go "Oh YEAH!" (or some such similar form of exclamation).

There are also tiny bubbles on the walls which you can grab to get a protective force-shield. The force-shield is good for one hit.

Score System:

The score you accumulate is a factor of the distance you've covered. This is naturally dependent on how long you manage to survive and how many power-boosts you gain. Destroying attackers is great fun but unfortunately, it doesn't contribute to your score.

The Good:

- Good replay value.

- Cute visuals.

- Addicting gameplay.

- FREE!

The Bad:

- Really simple (can be seen as a good thing too)

- Needs more bad guys.

- Needs a better scoring system.

- No unlockables? :(

Get NinJump on the AppStore here.

iDream wallpaper done with the Gimp

2010-07-10T20:44:00.006+05:30

I did a nice wallpaper while listening to some cool House/Trance music and this is what I ended up with. Enjoy!

(1440 x 900 widescreen)

(1600 x 1200)

Game review: Prince of Persia - The Forgotten Sands for the PSP

2010-06-19T20:49:00.010+05:30

After the Prince of Persia trilogy that became a cult hit among gamers around the world, UbiSoft announced their departure from the current Prince storyline and their venture into a new cel-shaded version of the game. However, before leaving things out to dry, the publishers of the game decided that they would do a fourth title in the POP series – The Forgotten Sands. Prince of Persia: The Forgotten Sands was developed and released for multiple consoles including the Xbox, PS3, Nintendo Wii, DS and the PSP.

The Forgotten Sands is another epic adventure of the prince that takes place between the events of The Sands of Time and The Warrior Within. What’s really interesting is that the game for the PSP is not just another watered-down story of the one that exists on larger consoles. This time around, the creators decided that handheld owners warranted a unique experience for the Prince and as such the entire storyline is radically different from the one for the Xbox, PS3 and Wii.

THE PLOT:
The plot begins with a prophecy foretold to Ahihud, the mightiest of fire spirits - “You will die by the blade he brings. As sure as winter follows fall and day turns to night, a lonely hero with the blood of kings, no mortal soul can withstand his might”. Fearing that the prophecy would come to pass, Ahihud sends his minions to hunt down and kill all those with royal blood. King Sharaman, the Prince's father locks him in the palace for his own safety but the Prince pursues a mysterious guiding light which offers to help him find his enemy. The light turns out to be Helem, a spirit of time.

GAMEPLAY:
Ubisoft have taken the PSP game back to its roots by producing a 2.5D platformer(remember the classic Prince of Persia you used to play on DOS?) . The Forgotten Sands is in fact three-dimensional but not free roaming as you would expect in a 3D world. With the help of the spirit of time, the Prince can either accelerate time or slow it down. This makes for some pretty interesting gameplay and inventive puzzle solving. You can make a tiny sandstorm launch the Prince into the air by accelerating it or solidify by slowing it down. Time manipulation is not restricted to sands alone. Any object that Helem hovers over may be subject to acceleration or deceleration. Enemies can be slowed down to a crawl for a short while so that you can quickly dispatch them. Traps can also be brought to a grinding halt for you to safely get past them. As you run through the game, you find glowing orbs of magic called Elixir. Collecting these allow you to purchase upgrades for the Prince. The upgrades are either combat improvements (new combos) or health improvements (extending the health bar for longer life). The good old drinking fountain is still in use as it serves as a checkpoint for the game.

COMBAT:
Combat is pretty simplistic in The Forgotten Sands. Basic combat involves mashing the square button to hit enemies. You can use the circle button to dodge or throw enemies into the air. You can also use combos in combat once you’ve unlocked them using collected elixir. Most of Ahihud’s minions are pretty easy to take down and don’t really pose a threat. Bosses, however, can be a different story.

GRAPHICS AND ENVIRONMENT:
Although, the graphics of the game cannot compete with that of larger consoles, It still looks marvellous on the PSP. The artists have paid attention to minor details such as wind being swept in the desert or tiny particles pulsing in a magic world. The cutscenes are engrossing and there’s nothing more rewarding than watching a brand new cutscene of the game after clearing a particularly irksome level. The environment is truly exotic giving you a “wish I were there” feel. Crumbling platforms are common especially in the later levels where you are engaged in a mad rush to clear the level without stopping even for a moment’s breath!

MUSIC:
The soundtrack of the game keeps you right in the thick of it, from the arabic-inspired scores to the dark overtones of danger. Voice acting is spectacular as the story unravels through conversations between the Prince and Helem.

VERDICT:
Fans of the POP Franchise would surely want this game since the story is completely different from the other console versions. The game offers some replay value too by allowing replaying of levels to better your time or collect elixir.

Two new flavors of spam.

2010-05-23T01:26:00.002+05:30

Google Buzz comes to the BlackBerry

2010-04-10T23:05:00.016+05:30

A lot of folks have been complaining about Google ignoring the BlackBerry while the iPhone and Android-based mobiles are given preference. They are quite right! Currently, the Gmail mobile application does not have Buzz integration for BlackBerry while Android and the iPhone do. However, Google isn't Evil and so, Buzz has finally reached the BlackBerry as part of the Google Maps 4.0 mobile application. While the Maps app also comes with a lot of other new features for the BlackBerry (voice enabled search, Google Labs integration), the highlight for a social user like me was the Google Buzz feature.

Buzz comes as a layer with Maps. Simply enable this Layer and then buzz all you want. You can also post pictures as part of the buzz by selecting a photo stored on your device memory. This isn't exactly like some of those amazing Twitter apps that allow you to take a photo with your built-in camera and tweet it right away but at least its something. As far as I can tell, you can't post a buzz message without tagging it with your location. Considering that this is a Maps application, I guess opting out of specifying the Buzz location isn't part of the deal. I would really like the freedom to preserve my privacy, though. Buzz has been implemented in full swing for this application and I'm sure its only a matter of time before Google rolls it out as part of their Gmail app for the BlackBerry.

For a full listing of all the features provided by Google Maps 4.0, read the Google's official blog post here.

Twitter icons and badges.

2010-02-20T23:40:00.008+05:30

Enjoy these twitter badges and icons!
Some of these images contain transparency. What does that mean? It simply means that you can overlay the image against a background and you will be able to see a portion of the background through it.

Bubble Twitter:

These bubbles really go best against a black background.

Waving Tweety:

Dark Glass Bird:

If you need any customization for these icons in terms of colour or resolution, feel free to holler at me and I'd be happy to look into it. All these icons were created using the Gimp - a free and open source image editing tool.

Snow flakes particle system in WPF

2010-02-15T01:07:00.007+05:30

Hi all! While playing around with a rudimentary particle system that I created, I thought it might be fun to create a screen saver that will do a cool Compiz Fusion style snow fall. Of course, this was just a fun exercise. The screen saver is not configurable at all, except through code.

A 3D Valentines day Greeting card.

2010-02-07T05:00:00.007+05:30

I'd like to showcase a 3D Greeting card concept created in WPF. Feel free to customize and send this card to others too. The attached readme file in the download package has some information on customizing the card.

System and Software Requirements:
A processor better than a PIV.
Windows XP SP2 (with .NET Framework 3.0 or higher installed), Windows Vista or Windows 7.
A graphics card is recommended but not required.

i "C" - Widescreen Wallpaper

2010-01-30T19:37:00.004+05:30

While experimenting with the Gimp, I designed this i "C" wallpaper and thought it was worth sharing. I probably could do an i "C++" or i "C#" version too!

What do you think?

Its a programmer thing

2010-01-24T17:48:00.006+05:30

I'm just trying my hand out at web comics and though I'm far from Penny Arcade or xkcd, I'd really like to give my readers something to smile about. :)

Testing iPhone Web Apps without an iPhone

2010-01-10T17:54:00.002+05:30

If you've ever felt the need to see what an iPhone web application looks like without an actual iPhone in hand, then check out http://www.testiphone.com.

AppStore in your web browser

2010-01-03T13:42:00.004+05:30

If you don't have the iTunes player installed on your machine, you can still view the AppStore in your web browser at http://app-store.appspot.com. Of course, all you can do is view apps. You cannot download or purchase any. There is also no option to change the AppStore country (defaults to United States). All the same, its nice to know that we don't need the iTunes player to simply browse the AppStore.

EDIT: I just found two other websites that allow you to browse the AppStore -
http://www.yappler.com and http://appshopper.com.

g.ho.st is really cool stuff!

2010-01-01T20:12:00.008+05:30

Recently, a few friends of mine pointed me to this awesome site - http://g.ho.st/
Its pronounced "Ghost". Ghost is basically a virtual computer on the internet and its been implemented really well. Best of all, the service is free! Head on over to the link above and check it out. Their intro video is a bit long-winded but it explains the concept of Ghost nicely.

EDIT: Looks like the g.ho.st folks couldn't quite manage to pull off the service as a freebie. I received a mail from them which ran as follows:

"Dear Ghost User,

We hope you have been enjoying our free Ghost service. Regrettably changes in the marketplace mean that it is no longer economical for us to host the Ghost service and we will be closing down the service on or around March 15. We will instead be focusing on licensing or selling our technology to larger companies.

We advise you to migrate ALL important folders, files and emails to another secure place before March 15. You might like to consider Google Docs or Microsoft SkyDrive for files and services such as Gmail or Yahoo! Mail for email. Some instructions for migrating data are included below.

We are really sorry for any inconvenience this may cause you and are very grateful for the fantastic support we had from our community."

Well, nothing lasts forever. That's a darn shame!

Season's Greetings

2009-12-27T11:38:00.002+05:30

Its that time of the year when new and wonderful things happen. Wish you all a Merry Christmas and a Happy New Year!

LWUIT and WPF Gradients Mash-up #2

2009-11-24T09:22:00.023+05:30

"On the last episode of Angelo's Stuff..."
We saw how to create a multi-coloured linear gradient. We also learnt the concept and purpose of gradient stops. This time around, we're going to dive into radial gradients.

What's so hard about radial gradients?
First off, there are a couple of things that radically differentiate linear and radial gradients.

Linear radients are memory efficient. Only a small strip of an image needs to be made and that same image is tiled either horizontally or vertically across the area to be painted. Radial gradients are not tegular. We need an image that is as large as the area to be painted. A lot of memory is going to be used for a fancy effect. The good news is that the memory will be used up at run-time. So, the downloadable application isn't bloated.
Radial gradients have a lot of customization options. Since we're using up a large image, we might as well get our memory's worth.

Let's paint the town red!

The GradientStop class.
See previous post.

The RadialGradient class.

public class RadialGradient
{
   private Vector vGradientStops;
   private int radiusX, radiusY;
   private int marginTop, marginLeft;
  
   public final static int FILL = 0xffff;
   public final static int CENTER = 0xffff;

   public RadialGradient(  Vector gradientStops,
                           int radiusX, int radiusY,
                           int marginLeft, int marginTop   )
   {
       vGradientStops = new Vector();
       if(gradientStops != null)
       {
           //Ensure the gradient stops are ordered by offset in the member Vector.
           for(int i = 0; i < gradientStops.size(); ++i)
           {
               GradientStop newGradientStop =
                       (GradientStop) gradientStops.elementAt(i);
               int insertPos = 0;
               for(insertPos = 0; insertPos < vGradientStops.size(); ++insertPos)
               {
                   GradientStop existingGradientStop =
                           (GradientStop) vGradientStops.elementAt(insertPos);
                   if(newGradientStop.getOffset() < existingGradientStop.getOffset())
                   {
                       break;
                   }
               }

               vGradientStops.insertElementAt(newGradientStop, insertPos);
           }
       }

       this.radiusX        = radiusX;
       this.radiusY        = radiusY;
       this.marginTop      = marginTop;
       this.marginLeft     = marginLeft;
   }

   //Getters.
   public Vector getGradientStops()
   { return vGradientStops; }
   public int getRadiusX()
   { return radiusX; }
   public int getRadiusY()
   { return radiusY; }
   public int getMarginLeft()
   { return marginLeft; }
   public int getMarginTop()
   { return marginTop; }
}

The constructor of this class takes the following parameters:

A Vector of GradientStop. This allows us to use multiple colours within a single gradient.
An X radius. This is the width of the radial gradient. Specify RadialGradient.FILL in order to have the radial gradient fill the entire width of the painted area.
A Y radius. This is the height of the radial gradient. Specify RadialGradient.FILL in order to have the radial gradient fill the entire height of the painted area.
A left margin. This is the distance of the center of the gradient from the left-most point of the area to be painted. Specify RadialGradient.CENTER to have the radial gradient show up in the horizontal center of the painted area.
A top margin. This is the distance of the center of the gradient from the top-most point of the area to be painted. Specify RadialGradient.CENTER to have the radial gradient show up in the vertical center of the painted area.

What are these margins for?
The margins are basically used to space the radial gradient in the area to be painted. Assume that we have a radial gradient with an X radius and Y radius of 20 each. Now let's say that we want to paint this radial gradient at the top left of the painted area. Then all we need to do is specify left and top margins of 10 (half the respective radii). The illustration below should clarify things.

The Painter.
We're going to cache an image that is as large as the area to be painted. So, why restrict ourselves to a single radial gradient? Let's call our custom Painter - MultiRadialGradientPainter. The user of our Painter should be able to overlay multiple radial gradients over each other.

public class MultiRadialGradientPainter implements Painter
{
   private byte opacity;
   private Image cache;
   private Vector vRadialGradients;
   private int backFillColor;

   public MultiRadialGradientPainter(  Vector radialGradients,
                                       byte opacity, int backFillColor )
   {
       vRadialGradients    = radialGradients;
       this.opacity        = opacity;       
       this.backFillColor  = backFillColor;
   }

   //Special case overload for single Radial Gradients only.
   public MultiRadialGradientPainter(  RadialGradient radialGradient,
                                       byte opacity, int backFillColor )
   {
       vRadialGradients    = new Vector();
       vRadialGradients.addElement(radialGradient);

       this.opacity        = opacity;
       this.backFillColor  = backFillColor;
   }
  
   public void paint(Graphics g, Rectangle rect)
   {
       final Dimension d   = rect.getSize();
       final int x         = rect.getX();
       final int y         = rect.getY();
       final int width     = d.getWidth();
       final int height    = d.getHeight();       

       final int size = Math.max(width, height);
       if(cache == null || size != cache.getWidth())
       {
           cache = Image.createImage(size, size);
           Graphics dc = cache.getGraphics();

           //Set the backFillColor before drawing the gradients.
           if(backFillColor >= 0)
           {
               dc.setColor(backFillColor);
               dc.fillRect(0, 0, width, height);
           }
          
           for(int i = 0; i < vRadialGradients.size(); ++i)
           {
               final RadialGradient radialGradient =
                       (RadialGradient)vRadialGradients.elementAt(i);
               int radiusX = radialGradient.getRadiusX();
               int radiusY = radialGradient.getRadiusY();
               int marginLeft = radialGradient.getMarginLeft();
               int marginTop = radialGradient.getMarginTop();

               if(radiusX >= RadialGradient.FILL)               
                   radiusX = size;                   
               if(radiusY >= RadialGradient.FILL)               
                   radiusY = size;

               if(marginTop >= RadialGradient.CENTER)
                   marginTop = height / 2;
               if(marginLeft >= RadialGradient.CENTER)
                   marginLeft = width / 2;

               final Vector vGradientStops = radialGradient.getGradientStops();
               for(int j = vGradientStops.size() - 2; j > -1; --j)
               {
                   GradientStop thisGradientStop =
                               ((GradientStop)vGradientStops.elementAt(j));
                   GradientStop nextGradientStop =
                           ((GradientStop)vGradientStops.elementAt(j + 1));

                   drawRadialGradient(dc,
                           thisGradientStop.getColor(),
                           nextGradientStop.getColor(),
                           (int)(radiusX * (thisGradientStop.getOffset() / 100.0)),
                           (int)(radiusX * (nextGradientStop.getOffset() / 100.0)),
                           (int)(radiusY * (thisGradientStop.getOffset() / 100.0)),
                           (int)(radiusY * (nextGradientStop.getOffset() / 100.0)),
                           marginLeft, marginTop
                           );
               }
           }

           if(opacity < 255)
           {
               cache = cache.modifyAlpha(opacity);
           }
       }

       g.drawImage(cache, x, y);
   }

   //This routine does the job of drawing a radial gradient.
   private void drawRadialGradient(Graphics dc, int srcColor, int destColor,
                                   int startRadiusX, int endRadiusX,
                                   int startRadiusY, int endRadiusY,
                                   int marginLeft, int marginTop)
   {
       final int srcR = srcColor >> 16;
       final int srcG = srcColor >> 8 & 0xff;
       final int srcB = srcColor & 0xff;

       final int destR = destColor >> 16;
       final int destG = destColor >> 8 & 0xff;
       final int destB = destColor & 0xff;

       final int dx = (endRadiusX - startRadiusX);
       final int dy = (endRadiusY - startRadiusY);
       final int biggerDiff = (dx > dy) ? dx : dy;

       for(int i = biggerDiff; i > 0; --i)
       {
           final int interpolatedR =
                   (int)(srcR + ((destR - srcR) * ((float)i / biggerDiff)));
           final int interpolatedG =
                   (int)(srcG + ((destG - srcG) * ((float)i / biggerDiff)));
           final int interpolatedB =
                   (int)(srcB + ((destB - srcB) * ((float)i / biggerDiff)));

           final int interpolatedColor =
                   interpolatedB | (interpolatedG << 8) | (interpolatedR << 16);

           dc.setColor(interpolatedColor);

           final int currentRadiusX = startRadiusX + (i * dx / biggerDiff);
           final int currentRadiusY = startRadiusY + (i * dy / biggerDiff);

           dc.fillArc(
                   marginLeft - (currentRadiusX / 2),
                   marginTop - (currentRadiusY / 2),
                   currentRadiusX, currentRadiusY, 0, 360);
       }
   }
}

The constructor of MultiRadialGradientPainter takes the following arguments:

A Vector of RadialGradient. This allows us to have multiple radial gradients drawn by the painter.
Opacity. A byte value that controls the transparency of the entire painted image.
A back fill color. This colour will be used to fill the remainder of the space in the image where there is no gradient.

How about an example?
We have a simple LWUIT Form with a Label at the top (BorderLayout.NORTH).

The screenshot on the left shows the Form without the Label. The Form has two radial gradients - one on the top and the other in the center. The screenshot on the right shows the barebones Form with the Label. The Label has a linear gradient.

This is what the code for setting these gradients looks like:

{
 Vector vGradientStops = new Vector();
 vGradientStops.addElement(new GradientStop(0xffffff, (byte)0));
 vGradientStops.addElement(new GradientStop(0x434343, (byte)50));
 vGradientStops.addElement(new GradientStop(0xffffff, (byte)60));

 theLabel.getStyle().setBgPainter(
         new LinearGradientPainter(vGradientStops, (byte)127, false));
}
{
 Vector vGradientStops = new Vector();
 vGradientStops.addElement(new GradientStop(0x704700, (byte)0));
 vGradientStops.addElement(new GradientStop(0x251801, (byte)100));

 Vector vRadialGradients = new Vector();
 vRadialGradients.addElement(
         new RadialGradient(vGradientStops,
         RadialGradient.FILL, RadialGradient.FILL,
         RadialGradient.CENTER, RadialGradient.CENTER));

 Vector vSmallGradientStops = new Vector();
 vSmallGradientStops.addElement(new GradientStop(0xffa300, (byte)0));
 vSmallGradientStops.addElement(new GradientStop(0xffa300, (byte)50));
 vSmallGradientStops.addElement(new GradientStop(0x251801, (byte)100));

 vRadialGradients.addElement(
         new RadialGradient(vSmallGradientStops,
         RadialGradient.FILL, 50,
         RadialGradient.CENTER, 0));

 theForm.getStyle().setBgPainter(
         new MultiRadialGradientPainter(vRadialGradients, (byte)255, 0x251801));

}

Note that the linear gradient is at 50% opacity. When combining the two together, we get the effect as seen below.
Pretty neat, huh?

Is that all?
Well, yes. That's it. A word of caution: Use radial gradients sparingly. Remember that they require memory allocated for an image that is as large as the area to be painted. If we were to start using radial gradients for all our components then we would run into Out Of Memory exceptions. Also, expect the unexpected. If we do run into an OOM exception, we need to gracefully handle it and fall back on a less fancy UI.

Whew! That was a pretty long-winded post but I hope the MultiRadialGradientPainter proves useful to LWUIT designer/developers out there. If you find an issue with the code feel free to inform me and I'll be happy to look into it. Happy coding!

LWUIT and WPF Gradients Mash-up #1

2009-11-15T09:38:00.017+05:30

Shai Almog's blog is the one-stop-shop for all things LWUIT. I recently read his entry on GradientPainters and it floored me! I thought I could enhance it a bit by adding GradientStops to the LinearGradientPainter.

What is a GradientStop?
If you come from a WPF background, then you know exactly what a GradientStop is. The fillLinearGradient() routine in LWUIT allows us to smoothly transition between two colours. So, we could go from White to Black and end up with this.

However, if we want to smoothly transition between multiple colours then that's where GradientStops can help us out. Let's say we want to vertically transition from White to Red and then from Red to Black. We start with White at the top and transition to red halfway through. Then we go from red at the half position, all the way to black at the bottom. Your mind's eye should have a picture like the one below.

A GradientStop has an offset and colour. The offset is the percentage of the position at which the colour is the strongest. For example, in our multiple colour gradient example above, we would need two GradientStops.

GradientStop with offset 0 and colour White (0xffffff in LWUIT terms).
GradientStop with offset 50 and colour Red (0xff0000).
GradientStop with offset 100 and colour Black (0x000000).

Where's the code?
First, the implementation of the GradientStop class.


public class GradientStop
{
   private int color;
   private byte offset;

   public GradientStop()
   {
       color = 0x000000;   //Default Black at offset 0.
       offset = 0;
   }

   public GradientStop(int colorVal, byte offsetVal)
   {
       color = colorVal;
       offset = offsetVal;
   }

   public int getColor()
   {
       return color;
   }

   public int getOffset()
   {
       return offset;
   }

   public void setColor(int value)
   {
       color = value;
   }

   public void setOffset(byte value)
   {
       offset = value;
   }
}

Now, comes the implementation of the enhanced LinearGradientPainter.


public class LinearGradientPainter implements Painter
{
   private boolean horizontal;
   private byte opacity;
   private Image cache;
   private Vector vGradientStops;

   public LinearGradientPainter(   Vector gradientStops,
                                   byte opacity, boolean horizontal)
   {
       vGradientStops = new Vector();

       if(gradientStops != null)
       {
           //Ensure the gradient stops are ordered by offset in the Vector.
           for(int i = 0; i < gradientStops.size(); ++i)
           {
               GradientStop newGradientStop =
                       (GradientStop) gradientStops.elementAt(i);
               int insertPos = 0;
               for(insertPos = 0; insertPos < vGradientStops.size(); ++insertPos)
               {
                   GradientStop existingGradientStop =
                           (GradientStop) vGradientStops.elementAt(insertPos);
                   if(newGradientStop.getOffset() < existingGradientStop.getOffset())
                   {
                       break;
                   }
               }

               vGradientStops.insertElementAt(newGradientStop, insertPos);
           }
       }

       this.horizontal = horizontal;
       this.opacity = opacity;
   }

   public void paint(Graphics g, Rectangle rect)
   {
       final Dimension d   = rect.getSize();
       final int x         = rect.getX();
       final int y         = rect.getY();
       final int height    = d.getHeight();
       final int width     = d.getWidth();

       //Horizontal painting of gradient.
       if (horizontal)
       {
           if (cache == null || width != cache.getWidth())
           {
               cache = Image.createImage(width, 1);               
               Graphics dc = cache.getGraphics();

               for(int i = 0; i < vGradientStops.size() - 1; ++i)
               {
                   GradientStop thisGradientStop =
                           ((GradientStop)vGradientStops.elementAt(i));
                   GradientStop nextGradientStop =
                           ((GradientStop)vGradientStops.elementAt(i + 1));

                   dc.fillLinearGradient(thisGradientStop.getColor(),
                          nextGradientStop.getColor() ,
                          (int)(width * (thisGradientStop.getOffset() / 100.0)),
                          0,
                          (int)(width * (nextGradientStop.getOffset() / 100.0)),
                          1, horizontal);
               }

               if(opacity < 255)
               {
                   cache = cache.modifyAlpha(opacity);
               }
           }
           for (int iter = 0; iter < height; ++iter)
           {
               g.drawImage(cache, x, y + iter);
           }           
       }
       //Vertical painting of gradient.
       else
       {
           if (cache == null || height != cache.getHeight())
           {
               cache = Image.createImage(1, height);               
               Graphics dc = cache.getGraphics();

               for(int i = 0; i < vGradientStops.size() - 1; ++i)
               {
                   GradientStop thisGradientStop =
                           ((GradientStop)vGradientStops.elementAt(i));
                   GradientStop nextGradientStop =
                           ((GradientStop)vGradientStops.elementAt(i + 1));

                   dc.fillLinearGradient(thisGradientStop.getColor(),
                           nextGradientStop.getColor(),
                           0,
                           (int)(height * (thisGradientStop.getOffset() / 100.0)),
                           1,
                           (int)(height * (nextGradientStop.getOffset() / 100.0)),
                           horizontal);
               }

               if(opacity < 255)
               {
                   cache = cache.modifyAlpha(opacity);
               }
           }
          
           for (int iter = 0; iter < width; ++iter)
           {
               g.drawImage(cache, x + iter, y);
           }           
       }
   }
}

How do I use it?
Well usage is pretty simple. Here's an example for our previous multi-gradient case.


Vector vGradientStops = new Vector();
vGradientStops.addElement(new GradientStop(0xffffff, (byte)0));     
vGradientStops.addElement(new GradientStop(0xff0000, (byte)50));     
vGradientStops.addElement(new GradientStop(0x000000, (byte)100));

myComponent.getStyle().setBgPainter(
             new LinearGradientPainter(vGradientStops, (byte)255, false));

Where do I go from here?
Let your imagination run wild!
What about the RadialGradientPainter?
I haven't forgotten about that. I thought I'd cover just one GradientPainter in this post so as not to bog the reader down. A multi-colour RadialGradientPainter will be covered in a future post.

Have fun!

My new BlackBerry Bold 9000

2009-10-29T17:49:00.003+05:30

I recently had a windfall when I attended a two-day workshop on Mobile Technologies jointly organised by the Computer Society of India (Trivandrum) and IEEE. The folks from Research In Motion (RIM), Ms. Annie Mathew and Mr. Ranjan Moses were kind enough to give me a BlackBerry Bold 9000. I really must thank them for that. Initially I thought that the phone was aimed at business enterprise users (and I'm not one) but once I got into the details, I found that it had stuff for me too. I can use the phone to play music, watch videos, read e-books and, of course the most important thing, to show off. Apart from showing off, all of these can be done by my PSP but I tend not to look a gift horse in the mouth. As a developer, there's nothing more satisfying than getting your hands on a fancy gadget and writing apps for it. I plan to do just that.

Here are my two cents on the BlackBerry Bold 9000:
1. Great Joystick. Tickles my finger as I use it giving me good feedback.
2. No touch screen and a run-of-the-mill user interface but this is a business phone, remember? You're paying for the technology that's inside not its external appearance.
3. What's inside? Well plenty. Push technology, data encryption and the like.
4. Great audio and video quality and a 2MP camera to boot.
5. The voice command feature... Just speak into the phone and say "Call <name>" and the phone automatically dials that person's number.
6. The battery life is pretty good too.

A custom tooltip in WPF

2009-10-03T18:45:00.004+05:30

Customizing tooltips in WPF is as easy as pie. The following XAML code demonstrates this:


<Style x:Key="{x:Type ToolTip}" TargetType="ToolTip">
     <Setter Property="OverridesDefaultStyle" Value="true"/>
     <Setter Property="HasDropShadow" Value="True"/>
     <Setter Property="Template">
         <Setter.Value>
             <ControlTemplate TargetType="ToolTip">
                 <Border CornerRadius="7" HorizontalAlignment="Center" VerticalAlignment="Top" Padding="5" BorderThickness="3,3,3,3">
                     <Border.Background>
                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                             <GradientStop Color="#CF181818" Offset="0"/>
                             <GradientStop Color="#BE1C1C1C" Offset="1"/>
                         </LinearGradientBrush>
                     </Border.Background>
                     <Border.BorderBrush>
                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                             <GradientStop Color="#80FFFFFF" Offset="0"/>
                             <GradientStop Color="#7FFFFFFF" Offset="1"/>
                             <GradientStop Color="#FFFFF18D" Offset="0.344"/>
                             <GradientStop Color="#FFFFF4AB" Offset="0.647"/>
                         </LinearGradientBrush>
                     </Border.BorderBrush>
                     <StackPanel>
                         <TextBlock FontFamily="Tahoma" FontSize="11" Text="{TemplateBinding Content}" Foreground="#FFFFFFFF" />
                     </StackPanel>
                 </Border>
             </ControlTemplate>
         </Setter.Value>
     </Setter>
</Style>

Here's a screenshot of a normal tooltip against the custom tooltip.

Take Control of your Scroll

2009-09-22T17:17:00.009+05:30

I recently ran into a specific issue when developing for a Windows Mobile environment. I had a lot of controls inside a Windows Form and by setting the Form's AutoScroll property to true, I could automatically scroll the contents of my form. This was quick and easy but then I found that the scrolling happened one pixel at a time which was just too slow. It would not really matter in most cases but in this case, I had to support the TouchFlo scrolling gesture. Thus began a 2-day hunt for an appropriate solution.

Attempt #1:
The first thing I looked for was some sort of property or method which could increase the scroll step. Nothing.

Attempt #2:
The next thing to try was take complete control of the scrolling. I put in my own scrollbar and handled the Scroll event of the scrollbar. This was a reasonable approach but then I realized that the Touch Flo scroll gesture did not work for me. I slapped my forehead and proceeded to the next attempt.

Attempt #3 (Final Solution):
The only other real solution was to take control of the Windows pumping messages. It turns out that you can override the WndProc function for Windows Forms. When it comes to the .NET Compact Framework, though, you can’t do that because its just not supported. I googled for an alternative and found this. I really must thank Mike Underhill for bailing me out here.
Third time’s a charm, they say and it seemed true in my case. This is what I ended up with.


private const int WM_VSCROLL = 0x115;
private const int GWL_WNDPROC = -4;
private const int SB_LINEUP = 0;
private const int SB_LINEDOWN = 1;

delegate IntPtr WndProcDelegate(IntPtr hWnd, uint msg,
IntPtr wParam, IntPtr lParam);

//Win32 APIs that I need.
[DllImport("coredll.dll", EntryPoint = "GetWindowLong")]
private static extern IntPtr GetWindowLong(IntPtr hWnd, int nIndex);

[DllImport("coredll.dll")]
static extern int SetWindowLong(IntPtr hWnd, int nIndex, IntPtr newWndProc);

[DllImport("coredll.dll")]
static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd,
uint Msg, IntPtr wParam, IntPtr lParam);

private static IntPtr oldWndProc = IntPtr.Zero;
private static WndProcDelegate newWndProc;
private const long lowOrderMask = 0xF;

public IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
if (msg == WM_VSCROLL)
{
   long val = ((long)wParam & lowOrderMask);           

   if (val == SB_LINEDOWN)
   {    
      //Haven’t really found out why the Y position
      //was going negative but this seemed an easy fix. :p      
      AutoScrollPosition =
         new Point(0, - AutoScrollPosition.Y + step);
   }
   else if (val == SB_LINEUP)
   {
      AutoScrollPosition =
         new Point(0, - AutoScrollPosition.Y - step);
   }
  

   return CallWindowProc(oldWndProc, hWnd, msg, wParam, lParam);
}
}

//Constructor
public Form1()
{
InitializeComponent();

newWndProc = new WndProcDelegate(WndProc);
oldWndProc = GetWindowLong(pnlContainer.Handle, GWL_WNDPROC);
SetWindowLong(pnlContainer.Handle, GWL_WNDPROC, Marshal.GetFunctionPointerForDelegate(newWndProc));
}

Hope this helps someone who ever comes across this problem.

A simple loading animation in XAML.

2009-09-05T17:49:00.009+05:30

I'm starting to take an interest in XAML art and I'd like to share a simple loading animation with all you WPF programmers out there.


<Grid x:Name="AnimGrid" Width="125" Height="125" VerticalAlignment="Center" Visibility="Visible">

<Border HorizontalAlignment="Center" VerticalAlignment="Center" Background="#FF303030" CornerRadius="19">

  <Ellipse HorizontalAlignment="Center" Width="125" Height="125" VerticalAlignment="Center">

      <Ellipse.Fill>

          <RadialGradientBrush GradientOrigin="0.5,1.1">

              <GradientStop Color="#FFF1FF00" Offset="0"/>

              <GradientStop Color="#FF000000" Offset="1"/>

              <RadialGradientBrush.Transform>

                  <RotateTransform x:Name="EllipseTransform" Angle="0" CenterX="62.5" CenterY="62.5" />

              </RadialGradientBrush.Transform>

          </RadialGradientBrush>

      </Ellipse.Fill>

  </Ellipse>

</Border>

<TextBlock Text="Please Wait..." FontSize="16" FontWeight="Bold" FontFamily="Trebuchet MS" Foreground="#FFFFFFFF" Margin="11,47,-9,30" FontStyle="Normal">

  <TextBlock.BitmapEffect>

      <DropShadowBitmapEffect x:Name="TextBlockShadow" ShadowDepth="6" Direction="90" Softness="0.5"/>

  </TextBlock.BitmapEffect>

</TextBlock>

<Grid.Triggers>

  <EventTrigger RoutedEvent="Grid.Loaded">

      <BeginStoryboard>

          <Storyboard>

              <DoubleAnimation Storyboard.TargetName="TextBlockShadow" Storyboard.TargetProperty="Direction" RepeatBehavior="Forever" From="90" To="450" Duration="0:0:2" />

              <DoubleAnimation Storyboard.TargetName="EllipseTransform" Storyboard.TargetProperty="Angle" From="0" To="-360" RepeatBehavior="Forever" Duration="0:0:2" />

          </Storyboard>

      </BeginStoryboard>

  </EventTrigger>

</Grid.Triggers>

</Grid>

This is what the animation looks like:

My take on a Glass Button in WPF.

2009-07-28T12:03:00.002+05:30

The following video tutorial shows how to create a nifty glass button in WPF using Microsoft Expression Blend 2. This is the first time I've actually made a screencast and it didn't turn out too bad. I'm sure it could be better. So, feel free to comment on anything that you like or don't like.

SMSBalcony on LWUIT Featured Apps Gallery

2009-07-25T12:28:00.003+05:30

I've been working on this J2ME based mobile application named SMSBalcony and its been featured on the LWUIT Featured Apps Gallery. Check it out here. Some of the other apps in the gallery are much better though. :) Perhaps someday, I'll be skilled enough to do stuff like that.

Fate: Another Diablo Clone.

2009-07-19T10:09:00.006+05:30

Fate is a dungeon crawler released in 2005 by Wild Tangent for the PC. Prima Facie, it seems like just another Diablo clone but there's a lot more to it. Ever since I completed Diablo II (about 3 times with different warrior classes :) ), I lay in wait for another Diablo Clone to come my way. Titan Quest (released in 2006) was great and maybe I'll blog about that someday. Diablo III is still in the works. So, in the meantime, let's talk about Fate.

Here are some of the nice things that I noted about Fate:

The game isn't as dark and gritty as Diablo II. The graphics are a lot more kiddish. Its 3D though but I find that sometimes when 2D artwork is done well in can look a lot better than a 3D game.
You have a pet (a dog or a cat) that fights on your behalf and can run back to town to sell items. The pet can also be transformed into some of the monsters that we encounter by feeding it fish!
Death isn't as frustrating as in Diablo. If the player dies, Fate itself appears and offers to resurrect the player (at the cost of experience, gold or both).
The dungeon level layouts and monsters and treasures are randomized.
You don't have different character classes as in Diablo II. The decision to be groomed as a brawler, sorceror or something in between is made while playing the game (Like purchasing sorceror items, giving more priority to Magic points instead of Strength).

Hope you enjoy some of the screenies I've posted of Fate and check out the links below to know more about the game.

("Don't bite the townsfolk." My pet may look like a Widow Spider but its still a dog at heart.)

(Me and the boys taking care of business.)

("Neat particle effects, guys but that won't stop me from taking you OUT!")

Links:
Wiki link to Fate
Official Fate Game site

SuperFactory: A generic object factory implementation in C++

2009-07-18T12:37:00.003+05:30

If you ever wanted to use an object factory that works out of the box in C++, then this article written by Francis Xavier might help you out.

http://www.gamedev.net/reference/snippets/features/supFactory/

Cppcheck - An open source C++ static analysis tool

2009-07-06T11:21:00.004+05:30

How would you identify potential flaws in your code? Conducting a code review would make sure that:
1. Possible errors/exceptions are dealt with.
2. Proper design patterns and good coding idioms have been used.
3. Common logical errors are eliminated and more...

However if bugs were introduced by a human in the first place, then those self-same bugs could be missed during a code review. Human program-comprehension is not very reliable.

Now, what if there were a tool to conduct the code review? That's what Static Code Analysis is for. It involves the analysis of program code without actually executing it. Of course, unlike a human, a tool that automates the process of static analysis can't really consider design issues on a large scale. It can offer advice about certain basic design patterns and good programming practices but it can't go beyond that and look at the big picture.

There are plenty of great static analysis tools around. You can get a complete list here. If you're a C/C++ programmer, you might want to try out Cppcheck. Its been GPL licensed and has a QT application front end for those who don't want to get their hands dirty with the command line. :)

Wiki entry on Cppcheck
SourceForge Project site of CppCheck

AIMP2: A free Audio Player

2009-06-27T21:39:00.004+05:30

AIMP2 is a free audio player. While the player appears free for now, there might possibly be a paid version in the future. The look and feel of AIMP2 lies somewhere between players like VLC (not so great looking...) and WinAmp (overkill!). I found this player to be pretty feature rich and less buggy too.

Check it out at http://www.aimp2.us

Customizing the items in a WinForms ComboBox

2009-04-15T14:08:00.000+05:30

The combo box is one of the favoured means by which users can select one from a group of pre-defined options. It provides a neat interface and reduces on-screen clutter. The items in a combo box are strings by default and for most cases, string items are sufficient for presenting data to the user. For example, a list of cities like "Wayanad", "Trivandrum" and "Ernakulam". However, there may be cases where strings are not enough.

What do we have?
We have an application that displays a demographic map of civil conflict. Areas on this map are categorised as high, medium and low risk. High risk areas are characterized by a red colour, medium risk areas are yellow and low risk areas are grey.
Now, these legend colours need to be presented to the user (There are only three colours here but there could be more). Further more, the user might want to select an area of risk and additional data will be presented to the user based on his/her selection.

What do we need?
We need more than just a standard combo box, we need a customized combo box! Let's call this type of combo box a LegendComboBox. A LegendComboBox will display a rectangle with a colour inside it along with a string. This can be accomplished by manually drawing the items inside the combo box instead of letting it be drawn for us.

How do we get what we need?
Before we dive into creating our LegendComboBox, we need to realize the item(s) that this combo box will hold. Obviously, a simple string won't do because we also need to specify the legend colour for that string. In order to store this information, let's create a new class named LegendItem.


//The type of item that can be added to a LegendComboBox.
public class LegendItem
{
public object Data { get; set; }
public Color Color { get; set; }
}

Now, that we know what type of items will be added to the LegendComboBox, let's create the combo box itself.

Step1: We start by deriving our LegendComboBox from System.Windows.Forms.ComboBox.
That way it looks and smells just like a regular combo box.

Step2: In the constructor of LegendComboBox we do two things.
First, we set the DrawMode of this combo box to OwnerDrawVariable. This indicates that we want to manually draw the items in the combo box. Secondly, we register a function with the DrawItem event. This function will be invoked whenever a particular item in the combo box is to be drawn on the screen.


public class LegendComboBox : System.Windows.Forms.ComboBox
{
   public LegendComboBox()
   {
    this.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawVariable;
    this.DrawItem += new DrawItemEventHandler(LegendComboBox_DrawItem); 
    ...   
   }
}

Step3: The next step is to actually define the function that we registered with the DrawItem event of our combo box. This function will have a prototype of:
void LegendComboBox_DrawItem(object sender, DrawItemEventArgs e);

DrawItemEventArgs provides data about the item to be drawn.
This data includes the index of the item to be drawn, the graphics surface on which to do the drawing, and the area within which we can do the drawing.


void LegendComboBox_DrawItem(object sender, DrawItemEventArgs e)
{
e.DrawBackground();
LegendItem currentItem = null;
Rectangle rect = new Rectangle(2, e.Bounds.Top + 2,
                               e.Bounds.Height, e.Bounds.Height - 4);
try
{
   currentItem = (LegendItem)this.Items[e.Index];
}
catch (InvalidCastException)
{           
   //If the item in the combo box is not of type LegendItem,
   //then we just draw the item without the legend colour.
   e.Graphics.DrawString(this.Items[e.Index].ToString(), this.Font,
       new SolidBrush(this.ForeColor), e.Bounds);

   return;
}

//Draw rectangle with legend colour.
e.Graphics.FillRectangle(new SolidBrush(currentItem.Color), rect);
e.Graphics.DrawString(currentItem.Data.ToString(), this.Font,
   new SolidBrush(this.ForeColor),
   new Rectangle(e.Bounds.X + rect.Width + 2,
                   e.Bounds.Y, e.Bounds.Width, e.Bounds.Height));           
}

That's it. We're done.

How do we use what we've got?
Using the LegendComboBox is pretty straightforward. Create an instance of this class and then add LegendItems to it.


LegendComboBox cboLegend = new LegendComboBox();
cboLegend.Items.Add(new LegendItem { Data = "High Risk", Color = Color.Red });
cboLegend.Items.Add(new LegendItem { Data = "Medium Risk", Color = Color.Yellow });
cboLegend.Items.Add(new LegendItem { Data = "Low Risk", Color = Color.Gray });

A better solution would be to make this LegendComboBox a control that can be used in any WinForms application.

What have we learnt?
Through an example, we've seen that a WinForms combo box can be customized to display more than just string data. As a matter of fact, the DrawItem event is available for the ListBox and TabControl controls as well. Also, we aren't restricted to just drawing shapes for our items, we could even draw images and more.

Creating an uninstall shortcut for your MSI package

2009-02-12T11:21:00.000+05:30

Microsoft, as a general rule, expect every user to uninstall applications from the Add/Remove Programs tool in the Control Panel. However, there might be cases where one might want to add an 'Uninstall Program' shortcut to the Start->Programs Menu. The steps below are a walkthrough for creating a simple MSI package using Visual Studio 2008 and adding an 'Uninstall Program' shortcut to the Programs Menu as well.

Basic Walkthrough for creating an MSI Installation package in Visual Studio 2008.

Open the project for which an MSI Installation package is to be added in Visual Studio 2008.
Right click the Solution of the Project in the Solution Explorer and select Add->New Project from the context menu.
Expand the 'Other Project Types' category and choose 'Setup Project' from the 'Setup and Deployment category'. Enter a name and location for the MSI package to be created and click OK.
A Setup project will be added to the project solution. Right Click the Setup Project in the Solution Explorer and select View->File System from the context menu.
Right click 'Application Folder' in the new window and select Add->Project Output. Now, select 'Primary Output' from the dialog box that pops up and click OK. A 'Primary Output from xxx' entry should appear in the Application Folder. This is the main executable of the project.
Right click the 'Primary Output from xxx' entry and select 'Create Shortcut to Primary Output from xxx'. Repeat this step one more time to create two shortcuts.
Cut one of the shortcuts and paste it in the User's Desktop folder. Similarly cut the other shortcut and paste it in the User's Program Menu folder. Rename each of these shortcuts to something more appropriate (such as the application name).

Creating an Uninstall Program shortcut.

Browse to the MSI project folder (using Windows Explorer), right click and select New->Shortcut from the context menu. In the Create Shortcut Wizard dialog that pops up type '%windir%\system32\msiexec.exe -x {prodCode} ' as the location of the shortcut, where prodCode is the Product Code of the MSI package. This Product Code can be identified from the Project Properties of the MSI Project in Visual Studio. Also, provide a proper name for the shortcut (such as Uninstall xxx, where xxx is the name of the application) and click Finish.
The next step involves adding this shortcut to the User's Programs Menu folder of the MSI project in Visual Studio. The problem is that files with extension .lnk (extension of the shortcut) cannot be added to the Project. So, first we need to rename the shortcut extension from .lnk to .txt. Open up a DOS command window and browse to the location of the shortcut using the 'cd' command. Now type 'ren xxx.lnk xxx.txt' where xxx is the name of the shortcut item.
Now, simply drag the renamed shortcut into the User's Programs Menu folder of the MSI project.
Rename the shortcut from .txt back to .lnk.
Build the MSI project and the necessary setup files will be created in the bin folder of the project.

Hope this helps someone out. Have a good day.

Casting with Multiple Inheritance

2008-12-23T16:06:00.000+05:30

(Reader Level : Intermediate)
(Knowledge assumptions : C++ casts, Multiple Inheritance)

The Question:
Given the classes:

struct A { int _aValue; };

struct B { float _bValue; };

class C : public A, public B { };

Consider the following statements:

C objC;

void *pC = &objC;

A *pA = reinterpret_cast<A*>( pC );

B *pB = reinterpret_cast<B*>( pC );

...

Are both pA and pB valid? Why or why not?

The Answer:
pA is valid. pB is invalid.

The Reason:
Many feel that the order in which base classes are inherited does not matter for multiple inheritance. However, in some cases, it does matter. This is one of those cases.

When creating an instance of C, its A subobject will be instantiated first and then its B subobject. This behaviour is due to the fact that C inherits from A first and then from B. The 'this' pointer of the A subobject will be at an offset of 0 bytes from the 'this' pointer of objC. On the other hand, the B subobject will be at an offset of 4 bytes from the 'this' address of objC. The displacement of 4 bytes is attributed to the integer member _aValue of class A.
The following diagrams should make things clear.

Now, what happens when you cast from a void* to A*? The compiler doesn't know that the actual type of pC is C*. So, it assumes that pA can point to the 'this' address of pC. That's fair because the A subobject of an instance of C will be at the starting address of objC. However, when making the cast from void* to B*, the compiler assumes that the B subobject is at the starting address of objC. That isn't true and hence, pB is invalid.

Corollary:
Now that we know why pB is invalid, let's see if we can correct it. Obviously, reinterpret_cast is ugly and unreliable.
Would a static_cast do any better?
Unfortunately, no. A static_cast works at compile time and as stated before the compiler doesn't know anything about the actual type of pC.
How about a dynamic_cast?
A dynamic_cast would nip our futile attempts in the bud by refusing to cast from void* to anything.

The take-home message:
reinterpret_cast is bad but void* is evil!

The three aspects of a successful Software Engineer

2008-12-05T13:46:00.000+05:30

A wise person once told me that there are three aspects to a successful software engineer.

1. Attitude.
A person must have a good outlook and should always strive to do the best that he/she can. That defines attitude. A bad attitude could be attributed to the work environment (colleagues, work interest, monetary satisfaction, bosses etc.) but a good software engineer will try not to let such annoyances affect him.

2. Motivation.
Motivation means having a reason to do things. It gives a person a purpose and goal. If the odds are stacked against a person, then he/she must rise to the occasion.

3. Ability.
Ability involves the capability of a person. The ability of a software engineer is determined by the skills in his/her domain of expertise.

Now, here’s the interesting part. The aforementioned facets of a software engineer must go in that order of precedence. By having a good attitude and an “Up and at ‘em” disposition, one can discover motivation. Once a software engineer finds a reason to do something, then he/she will not quit until the job has been done and done well. A good attitude and proper motivation will naturally make a person pay attention to trivial details. It will make him or her push forward beyond normal limits and that’s what garners ability. An individual could be born with great skill but that could be put to little use unless he/she develops a good attitude.
Laugh in the most trying of times, never give up even if the chips are down and show others respect irrespective of whether you like them or not. That’s what a healthy attitude demands.

Eliminate duplicate elements from a container

2008-10-22T17:13:00.000+05:30

(Reader Level : Intermediate)
(Knowledge assumptions : templates, STL)

One of the grandest things about STL is that it keeps us from re-inventing the wheel. In a practical world, it just doesn't make sense for a developer to create a doubly linked list or a queue from scratch. We have STL containers for that purpose. However, with great knowledge comes great responsibility. Its important to know what STL does under the hood, rather than just using it blindly. A lot of books out there have covered this topic but one of the most important ones that springs immediately to mind is The C++ Standard Library - A Tutorial and Reference by Nicolai M. Josuttis.

Enough of the prologue... Let's get down to a problem. There are times when one might have a container with duplicate element values. Whether such a scenario is justifiable or not may depend on a number of things. The first thing, we need to look into is the container itself and ask ourselves - "Is this the right container for the job? Why not use an std::set or an std::map instead?" If redesigning our code to use a more suitable container isn't a viable solution, then read on.

template<class ContainerType>
void RemoveDuplicates( ContainerType& input )
{
 ContainerType::iterator currentPosIter = input.begin();
 currentPosIter;

 for( ContainerType::iterator iter = input.begin(); iter != input.end(); ++iter )
 {
   if( std::find( input.begin(), currentPosIter, *iter ) == currentPosIter )
   { 
     *currentPosIter = *iter;
     ++currentPosIter;
   }
 }

 input.erase(currentPosIter, input.end() );
}

The above function removes duplicates from any STL container as long as that container supports an erase method. Let's take it for a test drive, shall we?

std::deque<int> myDeque;

//Add some values to the deque.
myDeque.push_back(0);
myDeque.push_back(1);
myDeque.push_back(1);
myDeque.push_back(0);
myDeque.push_back(2);
myDeque.push_back(2);
myDeque.push_back(3);
myDeque.push_back(1);

//Before erasing duplicates.
std::cout << "Before erasing duplicates." << "\n";
std::copy( myDeque.begin(), myDeque.end(), std::ostream_iterator<int>( std::cout, "\n" ) );
std::cout << "\n\n";

RemoveDuplicates<std::deque<int> >( myDeque );

//After erasing duplicates.
std::cout << "After erasing duplicates." << "\n";
std::copy( myDeque.begin(), myDeque.end(), std::ostream_iterator<int>( std::cout, "\n" ) );

Template Parameter friends

2008-10-14T20:14:00.000+05:30

(Reader Level : Intermediate)
(Knowledge assumptions : templates, friend)

The problem:
Currently, the C++ standard does not allow you to write code like this:

template<class T1, class T2>

class MyClass
{
  friend class T1;
  friend class T2;
};

You can’t make the template parameter of a class be a friend of that particular class. This might seem a reasonable requirement but the language does not allow you to do this, at least not directly.

The workaround:
In order to accomplish what we require here’s a quick workaround.

For the GCC compiler:-

#define MAKE_FRIEND(T) friend class MakeFriend<T>::Result

template<class T>
class MakeFriend
{
public:
  typedef T Result;
};

template<class T1, class T2>
class MyClass
{
 MAKE_FRIEND(T1);
 MAKE_FRIEND(T2);
};

For Microsoft's compiler:-

#define MAKE_FRIEND(T) friend MakeFriend<T>::Result

template<class T>
class MakeFriend
{
public:
  typedef T Result;
};

template<class T1, class T2>
class MyClass
{
 MAKE_FRIEND(T1);
 MAKE_FRIEND(T2);
};

Note the use of the 'class' keyword in the MAKE_FRIEND macro for the GCC compiler but not for the Microsoft compiler. If either T1 or T2 is not a class, then your compiler will complain. For example, if you try to instantiate an object with:

MyClass<SomeClass, int> myClassObj;

then the GCC compiler will say error: invalid type ‘int’ declared ‘friend’. But that makes sense, doesn’t it?

The code above has been tested on GCC 3.4.5 and on Microsoft Visual Studio 2008 (using the Microsoft Compiler).

Alexandrescu to the rescue

2008-08-08T04:04:00.000+05:30

(Reader Level : Intermediate)
(Knowledge assumptions : templates, std::vector, std::string)
I've recently taken a fancy to Andrei Alexandrescu's Modern C++ design. Its a fabulous book and anyone who is serious about becoming a good C++ programmer ought to read it. However, the book is not for the novice or the faint of heart. Someone on CodeGuru even suggested that the reader wear a helmet while reading this book so that his/her brain would not explode!

Now let me tell my story...
I was writing a string tokenizer in C++. The basic idea was to split a parse string into tokens using another string as the delimiter. The resultant token strings can be returned as a vector of strings.

std::vector<std::string> Tokenize( const std::string& str, const std::string& delimitStr )
{
 std::vector<std::string> result;
  //////Rest of the code goes here...//////////

  return result;
}

Seems pretty sensible, right? Now here's the problem. What if I wanted to give the user the power to specify what kind of STL container he/she wanted to use. Perhaps, a list would be more pertinent, or maybe a deque. In order to do that the Tokenize() function needs to be templated. So here was my first attempt..

template<class Container>
Container Tokenize( const std::string& str, const std::string& tokenStr )
{
 Container result;
  //////Rest of the code goes here...//////////

  return result;
}

Alright, that seems nice enough and the user would have to call this Tokenizer() routine as:

Tokenize<std::list<std::string> >( "breakmeintoathousandpieces", "e" );

Unfortunately, that's redundant because we know that the result is a container of string tokens. Furthermore, the user should not be given the opportunity to misuse the algorithm by specifying something other than std::string for the template argument. It should be fair to simply say:

Tokenize<std::list>( "breakmeintoathousandpieces", "e" );

That won't work however because then the container type would be incomplete. I was wondering how to resolve this problem when it hit me! The use of Template Template Parameters was illustrated for designing Policy classes in Modern C++ Design. It suited my purpose wonderfully!
This is what my revised Tokenizer() function looked like:

template< template<class> class Container >
Container<std::string> Tokenize( const std::string& str, const std::string& tokenStr )
{
 Container<std::string> result;
  //////Rest of the code goes here...//////////

  return result;
}

This example was just to illustrate the use of template template parameters. As Alexandrescu so beautifully put it - "It is as if WidgetManager (the class he templated) were a little code generation engine, and you configure the ways in which it generates code."

If you really have a solid reason to tokenize anything complex, of course, I would recommend using Boost::Tokenizer.

Sorting Stuff with Heap Sort - Part III

2008-07-10T12:49:00.001+05:30

In part I and II of this series, we learnt about Heap Sort and how to construct a heap out of unsorted data. Now, let's move on. Once the heap is constructed, we need to sort it.

You might have noticed that the SIFT function takes a heap size as one of its arguments. If the SIFT function already knows what heap it is working on, why would it be necessary to pass in the heapSize separately? The reason is that SIFT doesn't have to sift a node through the entire heap. It can work with a smaller part of the heap. In the HEAPIFY routine, everytime we invoked SIFT, we passed a constant heap size to it but we would like to be able to specify a smaller heap size if we want. We'll see the reason for this soon.

We already know that the top-most node in any heap is the largest value. In order to sort the heap, what we do is swap the top node (or in other words the 0th element in the list) with the last node in the heap (the element whose index is inputDataList.length()-1). Now our largest value is at the bottom of the heap. Next, we reduce the size of the heap to be sorted and sift the top-most node using the reduced heap size as an argument. The top node, of course, has to be sifted so that we get a proper heap again. We keep swapping and sifting until the size of the heap to be sorted becomes zero.

The following algorithm performs sorting of a heap:


1. i = inputDataList.length()-1
2. while(i > 0)
{
3. SWAP(0, i)
4. SIFT(0, i)
5. i = i - 1
}

That's all there is to it. Here's some C++ code that I had written to augment this series. If the algorithms I've provided seem a bit vague, feel free to look at the code here. Also, check out this nice Heap Sort visualization here.

Firefox Download Day

2008-06-15T07:01:00.000+05:30

This post is a slight digression but you could think of it as a news update... I've just been informed along with some 21,000 odd Indians out there that the download day for Firefox is June 17th. I see a lot of Internet Explorer users blissfully using the worst browser that exists for a single platform - Windows! Firefox is free of charge, more secure, well-featured and open-sourced. What can IE do that Firefox cannot? The answer is nothing. So, then why use something that is second-rate? It's not that you have to shell out a packet to use Firefox. It's absolutely free! I guess, the only reason IE still exists is because it comes for free with Microsoft Windows.

Hopefully when Firefox 3 sets a world record for the most software downloaded in a 24-hour period, more web-users will sit up and take notice. We are a country with the second largest population in the world. Let's prove that we are also willing to embrace a future of free and open-source software by participating in this important event.

On a side-note, I wouldn't recommend any NIN fan opening http://remix.nin.com with IE6.

Sorting Stuff with Heap Sort - Part II

2008-06-10T13:07:00.000+05:30

Why do we call it ‘Heap’ sort?
Heap sort begins by building a heap of the data. A heap can be visualized as a binary tree where each parent node is greater than its successors. In practice, the heap can easily be represented by a simple array where the left and right children of the i^th node in the array will be at positions 2*i+1 and 2*i+2 respectively. For example, the following is a heap:

This heap above can be represented using an array as follows:

Note that the i^th element has the (2i+1)^th and (2i+2)^th elements as its children. The fact that the heap can be represented like this means that we can do an in-place sort without having to construct an entirely new data structure for storage. There are a couple of interesting features of the heap which are to be noted:

1. Each node is greater than its successors (for sorting in ascending order).
2. By virtue of (1), the largest node will always be on top of the heap.

Now that we know what the heap is, let’s see how we can generate such a heap out of unsorted data.

Building the Heap.
Before we talk about building a heap, we must first discuss a sifting procedure. The sifting procedure basically sifts a given node downward through the tree until it reaches its rightful place in the tree. I may keep using the term ‘node’ simply because its easier to visualize things that way but remember that in practice, a node is nothing but an element in a list. The sifting algorithm is pretty straight-forward.


Procedure SIFT(int siftNode, int heapSize)
1. Start with the position of the node to be sifted.
2. If either of the sift node’s children are larger than it, then swap the sift node with the larger of its children.
3. If neither of the sift node’s children are larger than it or the end of the heap has been reached then exit.
4. Otherwise, go to step 2.

Using the sift procedure, we can easily build an initial heap out of seemingly unsorted data. We start with the last node in the tree or in other words, the last element in the input data list. We then invoke our earlier sift procedure on this element. Then we move onto the previous element in the list and the cycle continues until we have sifted all of the elements in the list. The result will be a nice heap. For grasping the idea better, the following algorithm should suffice. Note that the algorithm assumes a zero based input data list.


Procedure Heapify()
1. siftNode = inputDataList.length()-1
2. while siftNode >= 0
 {
3. Invoke SIFT( siftNode, inputDataList.length() )
4. siftNode = siftNode – 1
 }

Sometimes, building an initial heap out of the input data is known as “Heapifying” the data. We are not done yet. The heap has to now be sorted and we'll see how that can be done soon. Until then, have a nice week!

Sorting Stuff with Heap Sort - Part I

2008-06-05T08:15:00.000+05:30

I’m starting a small series of blog posts that will explain the Heap Sort algorithm in depth. I’ve noticed that this is an academic topic that few are willing to touch but I am! I hope you find this short series informative.

The Basics.
First, lets get through the basics of any sorting algorithm. A sorting algorithm is an algorithm that seeks to arrange the elements of a data structure (think, a simple List) in a particular order. In most cases, we prefer the elements to be sorted in either ascending or descending order. The efficiency of an algorithm can be measured in terms of its Time Complexity or Space Complexity. The term Time Complexity refers to the amount of time that an algorithm takes to process the input and produce the desired output. The term Space Complexity refers to the amount of space or memory that an algorithm takes to produce the expected result. Generally, the complexity of an algorithm (time or space) is expressed as a function of the size of the problem, n. This is known as the Big-Oh Notation. So, if we were to say that a sorting algorithm has a time complexity of O(n), it means that the algorithm will take a factor of 10 units of time to sort 10 values. If the complexity of the algorithm were O(n²), then it would take a factor of 100 units of time to sort 10 values. Note that I have said that the algorithm will take "a factor of" time because this factor would depend on the particular problem. For example, if we were sorting simple integers, we could expect this factor to be a lot less than if we were sorting strings. Also, the complexity of an algorithm can be specified for Best, Worst or Average case scenarios. A best case scenario for a sorting algorithm would, of course, be if the data were already sorted in the first place. A worst case for a sorting algorithm would arise if the data were arranged in a manner that is contrary to the working of the algorithm. Generally, a good algorithm is measured for its worst-case scenario but in some cases, we also consider the average case.

Heap Sort is an O(nLogn) time complexity algorithm. This is in stark contrast with other sorting algorithms such as Bubble Sort (the unjustifiably most famous sort) which has an average or worst case complexity of O(n²). In my next post, we will dive into the Heap Sort algorithm and find out the reason as to why its called Heap Sort in the first place.

Why use a wrist-watch?

2008-05-27T20:03:00.000+05:30

Of late I've been going around without a wrist-watch. I've reasoned that the time display is now a feature provided by many other gadgets that I tend to carry such as my mobile phone or my iPod. Worst case, I could always accost someone and ask them the time. However, there was one particular situation where I actually needed my wrist-watch and it wasn't available - while writing my exams. I obviously couldn't whisk out my mobile (or worse my iPod) and tell the time. It would be rather obtrusive if I brought my analog alarm clock to the exam hall and kept it on my desk. So, the only other alternative was my wrist-watch. The only problem was that I hadn't used my wrist-watch for a very long time and its battery had died. In the end, I just requested the invigilator to inform me as each hour went by.

All along, I've felt that wearing a wrist-watch was more of a fashion statement than anything else. Reminds me, I've got to remember to replace the battery in my watch even if I don't actually wear it.

Setting up Code::Blocks on Windows

2008-05-12T01:12:00.000+05:30

This blog post is a how-to manual on how to set up Code::Blocks for Windows along with some other libraries such SDL and GTK+.

What is Code::Blocks?
Code::Blocks is an Integrated Development Environment(IDE) for C++. This means that it provides a convenient means for programmers to type and execute their programs. You will need to provide a compiler for any IDE and there are several C/C++ compilers for the Windows environment. Since, this walk-through is newbie oriented, I will simply assume that you do not have any particular compiler in hand.

Setting up Code::Blocks on Windows.
In order to set up Code::Blocks for your Windows OS, go to http://www.codeblocks.org/downloads/5 . You will see two setup files for Windows 2000/XP/Vista. The first setup assumes that you already have a compiler to use with the IDE. The second setup, comes with the MinGW compiler for Windows. Download this setup from its Sourceforge link. Once you've downloaded the file codeblocks-8.02mingw-setup.exe, then do a full install of the IDE. I'm going to assume that the selected installation path for the IDE is C:\Program Files\CodeBlocks. The installation is pretty straight-forward and there should not be any problems. Try creating a new Console Application using the Project Wizard.

Setting up Simple DirectMedia Library for Code::Blocks on Windows.
Setting up SDL for Code::Blocks is pretty easy. Download the SDL 1.2 development bundle from the direct link here. Untar the contents of the file. You should get a folder named something like SDL-1.2.13 and within that folder you should find folders named include, lib, bin etc. Code::Blocks expects to see the file SDL.h within the include folder but as of now, if you look inside the include folder, you will find another folder named SDL. Copy all the header files from within the SDL folder one level up to the include folder and delete the folder SDL. Then, copy the entire SDL-1.2.13 folder to C:\Program Files\CodeBlocks. Now, fire up Code::Blocks and try creating a sample SDL project using the Project Wizard. When asked to specify SDL's location, just provide the path as C:\Program Files\CodeBlocks\SDL-1.2.13. Hopefully, everything should go as planned.

Setting up GTK+ for Code::Blocks on Windows.
Setting up GTK+ for Code::Blocks is even easier. Download the GTK+ development bundle from the direct link here. This zip file is a tarbomb, so neatly unzip the contents of this file to a folder named gtk+-bundle-2.12.9. Copy this entire folder to C:\Program Files\CodeBlocks. Now try creating a new GTK+ project using the Project Wizard. When asked to specify GTK's location, just provide the path as C:\Program Files\CodeBlocks\gtk+-bundle-2.12.9.

const_iterator : Safety or Necessity?

2008-05-10T18:10:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : const-correctness, std::vector, iterators)
A while back I asked a senior programmer a very naive but valid doubt.
"Are const iterators used only to enforce safety or are there cases where they could be absolutely necessary?"
In reply, this is what I got and the answer was clear.


#include <iostream>
#include <vector>

class A
{
private:
std::vector<int> _vector;

public:
void Init()
{
   _vector.push_back( 1 );
   _vector.push_back( 2 );
   _vector.push_back( 3 );
}

void Display() const
{
   for(std::vector<int>::const_iterator itr = _vector.begin(); itr != _vector.end(); ++itr)    
      std::cout << (*itr) << std::endl;
}
};

int main(int argc, char *argv[])
{
A a;

a.Init();
a.Display();

std::cout<<"\n\n";
return 0;
}

If we were to try replacing the const_iterator in the Display() function with a normal iterator, the code would simply not compile. This is because the Display() routine is itself const and hence, we must guarantee that no member functions are altered within it. A normal iterator cannot give such a guarantee but a const_iterator can.

Code Storm#1 Solutions

2008-05-04T15:14:00.000+05:30

In response to my previous post of the Great Triangle Challenge here are the results:

This is how I managed to solve the problem.


#define ABS(X) ( ((X) < 0)?(-(X)) : (X) )

void Pyramid(const int n)
{
   for(int count = 0; count < (n*2 - 1)*n; ++count)
   {
     ((count/(n*2-1) - ABS( count%(n*2 - 1)-(n-1) ) + 1) > 0) ?
     std::cout<<(count/(n*2-1) - ABS( count%(n*2-1)-(n-1) ) + 1) :
     std::cout<<" ";

     if((count+1)%(n*2 - 1) == 0)
         std::cout<<std::endl;
   }
}

Hopefully, the code comments help in explaining the algorithm. The basic idea revolves around the fact that every row contains n*2 - 1 entries including the spaces to be printed. Let's call this the lengthOfRow. Hence, everytime the count becomes a factor of n*2 - 1, we print a newline. Also, we calculate the deviation of a value from the central value in each row. This is done by saying count%lengthOfRow - (n-1). If this deviation is found to be a positive deviation from the maximum value of that row, then we print it otherwise a whitespace is displayed.

Verdict: This method is relatively fast if compiler optimizations are turned on. The code is quite unreadable, though and it uses one extra variable in a single loop.

This method was provided by Francis Xavier, my elder brother. ;)


void Pyramid(int num)
{
    // We can only print numbers upto 1.
    if( (num % 10) < 1 ) return;

    if( num > 1)// Print the upper rows first.
        Pyramid( num - 1 );

    // Print this row
    switch( (num % 10) - 1 )
    {
        case 0: std::cout << "        1        " << "\n"; break;  
        case 1: std::cout << "       121       " << "\n"; break;   
        case 2: std::cout << "      12321      " << "\n"; break;   
        case 3: std::cout << "     1234321     " << "\n"; break;   
        case 4: std::cout << "    123454321    " << "\n"; break;   
        case 5: std::cout << "   12345654321   " << "\n"; break;   
        case 6: std::cout << "  1234567654321  " << "\n"; break;   
        case 7: std::cout << " 123456787654321 " << "\n"; break;   
        case 8: std::cout << "12345678987654321" << "\n"; break;   
    }
}

Look at the code closely and you will notice the ingenuity involved. First of all, the necessity to use an extra variable is circumvented because the count is wrapped up in the number of rows. Another idea which I certainly had not thought of was the use of recursion to perform some sort of looping. Finally, the best part was the idea to hard-code the nine rows but in an elegant manner.

Verdict: This method is extremely efficient. It uses no extra loops or variables. Another advantage going for it is that the code is extremely easy to read (unlike my method). Fantastic!

If anyone feels that they have a better algorithm than the one provided by Francis Xavier, feel free to email me at angelorohit[at]gmail[dot]com. Please don't attempt to post code in the comments section here as it is quite likely that the code would show up without proper formatting.

Code Storm#1: The Great Triangle Challenge

2008-04-28T00:50:00.000+05:30

I came across a nice C/C++ challenge on the web. Check it out here. Granted that's not a Pascal Triangle, it's just a pattern. In any case, the goal is to generate the pattern below using the fewest number of loops and variables.


        1
       121
      12321
     1234321
    123454321
   12345654321
  1234567654321
 123456787654321
12345678987654321

There are a few ground rules to be followed:

The number of rows displayed in the pattern is determined by the user at run-time. The minimum number of rows is zero and the maximum number of rows that the user can provide is 9.
You must have a function whose prototype is void Pyramid(int n) and this function must be invoked. Error checking for the number of allowed rows (0-9) need not be done within this function.
The variable n which is passed as an argument to Pyramid() is not counted as an extra variable.
You are free to use any number of extra functions. Every argument passed by value to an extra function will be counted as an extra variable. The main() routine of course, is an exception.
The term 'loop' refers to any looping construct of the language. This includes for, while, do-while and goto as well.
You are free to use any number of macros. Since, macros are effectively nothing but code substitution, macro arguments are not counted as extra variables.
printf() or the overloaded insertion operator of cout can be used for printing to standard ouput. Any other in-built library function that is used will involve weighing its internal source. For example, if you invoke strlen() once, then this would count as one extra loop but not an extra variable.
If two solutions use the same number of loops and the same number of variables, then the one that is more efficient in terms of time complexity will be the better solution.

If anyone does come up with a good solution to this problem, feel free to email me your source code at angelorohit[at]gmail[dot]com. Please don't attempt to post code in the comments section here as it is quite likely that the code would show up without proper formatting. I will post the worthy code in my next blog post. Have fun!

Movie Review: Into The Wild

2008-04-20T19:52:00.000+05:30

Normally I'm an action junkie when it comes to movies, so its funny that 'Into the Wild' was not an action flick. The basic plot is as follows: After graduating from Emory University, top student and athlete Christopher McCandless abandons his possessions, gives his entire $24,000 savings account to charity and hitchhikes to Alaska to live in the wilderness. Along the way, Christopher encounters a series of characters that shape his life.

Seems pretty boring, right? That's what I thought when I read the plot summary on IMDB but I watched the movie anyway. It turns out that I was wrong and the movie offers some great insights into the philosophy of life and the spirituality that one can gain through adventure. This film is based on a book by Jon Krakauer who wrote about the true exploits of an American wanderer named Chris McCandless. At the end of the movie, you may become a bit cynical (as I did) due to certain developments in the plot. Then I remembered that this is an actual true story and that I was entirely missing the take home message. At any rate, whether you like or dislike this film, you are sure to have several opinions about it. To give it credit, Into the Wild won the 2007 Golden Globe Awards and was also nominated for the Academy Awards. It has also received favourable reviews from most movie critics. The acting, in my humble opinion, was top notch. Emile Hirsch (of Alpha Dog fame) plays McCandless and does a pretty good job. The film was directed by Sean Penn who was also involved in production as well as screenplay. One of the biggest assets of the film is probably its great soundtrack. The music is truly beautiful and it keeps you in touch with each scene. Don't google anything about the film until you've actually watched it. Otherwise you're just ruining the whole experience!

Some links to check out AFTER you've watched 'Into The Wild':
Wiki on Chris McCandless
Official film site

Creating a custom GRUB bootsplash

2008-04-13T07:33:00.001+05:30

Creating your own GRUB bootsplash image does not require you to be an artist or an image-editing wizard. It's very easy.
Every GRUB bootsplash image must have the following characteristics:
a) Image format must be of the xpm format. GRUB will load compressed images even faster.
b) Image resolution must be 640x480, irrespective of whether your monitor is widescreen or not.
c) Image can only have a maximum 14 colours. No more.

Armed with these facts, let's go ahead and try to create our own bootsplash image. The image editing software that I am going to use for this purpose is the GIMP (GNU Image Manipulation Program).
First, pick out an image that you really like. The format doesn't matter at this point. It can be jpg, bmp, png, anything you like.

Now open the image in GIMP. Resize the image to a 640x480 resolution. Go to Image->Scale Image and set Width to 640 and the Height to 480. You can tweak the other settings in the same dialog if you want. After that click on the Scale button.

Next we need to make our image only have a maximum of 14 colours. So, go to Image->Mode->Indexed. Click on the Generate optimum palette radio button and set the Maximum number of colors to 14. Now we probably have a pretty ugly looking image. :)

Finally, save the image with extension xpm. You could call it something like bootsplash.xpm. Alright, we've got our image. Let's compress it. Open up a terminal and navigate to the folder where you saved bootsplash.xpm using the cd command. Then type:


gzip bootsplash.xpm

The gzip utility will compress our image and its name gets changed to bootsplash.xpm.gz. That's it! We're done. You can now set it as your new GRUB bootsplash. Enjoy!

By the way, this is what my own GRUB bootsplash looks like.

Mess around with your GRUB menu

2008-04-07T04:48:00.000+05:30

GRUB stands for GRand Unified Bootloader. I don't know why, but someone thought that it would be a funny play on the term "Grand Unification Theory" in physics. Essentially, GRUB is a bootloader program that loads when you boot into your PC. Using the GRUB menu, you can then pick your operating system of choice (if you happen to have more than one). I've been using Linux for a while now and today I'll show you how to tweak your GRUB menu settings so that it looks and behaves the way you might want it to. The Linux distribution that I currently use is Kubuntu 7.10. As such, many of the commands that I use may be Ubuntuish.

Let's get started. The options for your GRUB menu are stored in a file named menu.lst. Typically, this file will be located at /boot/grub. Before making any changes to menu.lst, let's first take a backup of the file. Open up a terminal and type the following:


sudo cp /boot/grub/menu.lst /boot/grub/menu.lst_backup

The shell should prompt you for your root password. Once you enter your password, the contents of the file menu.lst will be copied to another file named menu.lst_backup.
Now type:


sudo nano /boot/grub/menu.lst

to take a look at the menu.lst file. I'd imagine the file contents to be something like this.
Any line in this file that starts with a # symbol is a comment. This means that it will be safely ignored when GRUB reads this file.

1. Changing the default OS.
You can change the OS that loads by default in the GRUB menu. In order to do this, first count the entries in the menu starting from zero (not one). Now, locate the line in the menu.lst file that says default<space>n where n is literally a number. Change that number to the entry you want. For example, in order to make the first entry in the list as the default OS to be loaded, change the line in menu.lst to default 0
Save the file and exit the editor by pressing Ctrl+O and Ctrl+X (only for nano). A common mistake that many make is inadvertently change the commented line in the file. If there is a commented line leave it as is.

2. Changing the timeout.
Generally, the GRUB menu gives you about five seconds to decide which OS you want to boot. At the end of this time, GRUB automatically boots into the default OS. To change the timeout, simply find the line in menu.lst that says timeout and change it to timeout<space>n where n is the number of seconds you want to set. I usually set this value to 15. Save the file and exit the editor.

3. Changing the splash image.
Here's a fun customization that you can do. Most GRUB menu screens are purely black with white text. If you want to change the GRUB menu screen to that of a picture, you can easily do that. Get a nice GRUB splash image from the net. You can find plenty under the BootSplash section on http://www.kde-look.org
The grub splash image file should be something like filename.xpm.gz. If your splash image file is not in the xpm format, then it cannot be loaded by GRUB. Alright, now to set this picture as a grub splash, copy it to /boot/grub. Do the following:


sudo cp <PATH_TO_IMAGE> /boot/grub/bootsplash.xpm.gz

where PATH_TO_IMAGE is the logical path to the GRUB bootsplash image file that you intend to use. Now reopen menu.lst with root previleges.
sudo nano /boot/grub/menu.lst

Add a new line to this file (preferably after the initial comments):
splashimage /boot/grub/bootsplash.xpm.gz
Save and exit the editor.
Now everytime you boot your system, you should see the pretty new GRUB splash image instead of that boring dark one!

NOTE: If at any point, you realise that you've messed up your menu.lst file, then just retrieve it from the backup that we had first created.
Type:

sudo cp menu.lst_backup menu.lst

Kubuntu 7.10 CD request

2008-04-01T14:05:00.000+05:30

I feel quite happy today because the Kubuntu Gutsy CD that I requested from Canonical has arrived. I requested for the 32-bit version of the CD on the 7th of March and today is April Fool's. So, it totally took little more than three weeks to deliver the CD. I figured that since I lived in India which is quite some distance from the US, I'd at least have to pay for the shipping charges. The truth is that I didn't have to pay a dime, no shipping charges - nothing! A friend of mine told me that he had also got some free Ubuntu stickers along with his CD request. I didn't but that's okay because now I can make my own stickers. :D

https://shipit.ubuntu.com/

What is FLOSS?

2008-03-26T23:50:00.000+05:30

FLOSS stands for Free 'Libre' Open Source Software. It is a term that is used to represent software that has very limited restrictions on its license. Users of FLOSS are given the right to read and alter its source code. It is important to remember that free software does not mean that the software is free of charge. It means that the software is free from restrictions. Think of it in terms of "free speech" rather than "free food". Of course, there's lots of software out there that can be both. Just imagine a world where you don't have to simply file a bug report on the software that you use and then wait for the manufacturers to get back to you (which could be a very long wait!). Perhaps, if you have the technical knowledge, you could add to the software or call upon others to try and improve it. This would benefit not just you but all other users of that piece of software. Folks used to call such software that is free of restrictions as FOSS without the 'L'. However, this caused some level of ambiguity since it led to the assumption that one did not have to pay for the software. Such a notion would have spelt doom for any business prospects that such software might have. Once the word 'Libre' (meaning Liberty in Spanish or French) was brought in, the meaning became clear. So what FLOSS can you get? Well, apart from your dentist, here's an extensive list compiled by Wikipedia. I'm not too much of an activist. So, I wouldn't tell you to get rid of your proprietary (possibly pirated?) software. You probably use free software anyway. If you use Firefox, VLC or Gimp, then you are already a part of the solution. There are other useful applications that you could use. All it takes is an open mind to make a difference.

Other important links:-
Free Software Foundation
Info on Free and Non-free Software Licenses
Making the Move

An introduction to the STL : Priority Queues

2008-03-17T19:56:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : classes, std::vector, std::string, queues)
Hello all! This time we're going to look at another STL container - the Priority Queue. You probably know what a queue is but just in case you don't or your memory could use some jogging, here goes... A queue is a First In First Out data structure. It means that the first element you put into the queue is the first one to leave the queue. Think of it as one of those long queues at the supermarket. The sooner you enter the queue, the sooner you can leave. So what is a priority queue? A priority queue is a queue where elements are entered based on their priority. If the wife of the supermarket's Manager had to do some shopping, she might not have to wait in line(hypothetically speaking ;)). She could immediately walk to the front of the queue and check out her purchases. If the Manager's daughter were also present, then she would stand behind the wife because she doesn't get as much importance as the mother but is still more important than the rest of the frustrated patrons. I know, I know. Silly example but hopefully you get the idea. In order to illustrate the beauty of a priority queue let me describe a rather contrived problem. This question was presented to me for a programming competition held at my college university.

The Problem: Write a C++ program to accept a list of words from the user. The user must also enter a weight associated with each word. Finally, display the words in decreasing order of their weights.

Solution Attempt #1 : Using a vector:
The user having to enter words and associated weights is pretty basic stuff. So, I'm not going to write any of that code in order to keep this blog post as short as possible. Here's one possible way to do it with vectors.

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

//This class encapsulates a word that can be prioritized based on a number.
class PrioritizedWord
{
private:
 std::string m_word;
 int m_priority;

public:
 explicit PrioritizedWord()
 {}

 explicit PrioritizedWord(const std::string& word, const int priority = 0) : m_word(word), m_priority(priority)
 {}
           
 //Compares two words. This overloaded operator prioritizes words according to their weight.
 const bool operator <(const PrioritizedWord& pW) const
 {
     return (m_priority < pW.m_priority);
 }

 //Overloaded "put to" operator for streaming output.
 friend std::ostream& operator <<(std::ostream& out, const PrioritizedWord& pW)
 {
     out<<pW.m_word;
     return out;
 }
};

int main()
{
std::vector<PrioritizedWord>    vWords;

vWords.push_back(PrioritizedWord("Angelo", 23));
vWords.push_back(PrioritizedWord("This", -1));
vWords.push_back(PrioritizedWord("Here", 51));
vWords.push_back(PrioritizedWord("Was", -1));

std::sort(vWords.begin(), vWords.end());

for(std::vector<PrioritizedWord>::size_type i = 0; i < vWords.size(); ++i)
{
 std::cout<<vWords[i];
}

return 0;
}

We are sorting the vector contents using a function named sort that is available in the pre-compiled header <algorithm>. The working of the sort function is beyond the scope of this post but I'll provide a link at the end. Also, note the use of the overloaded less-than operator. We need to overload this operator because the sort() function will compare two PrioritizedWord's using it. Don't forget the const at the end of the operator definition. sort() expects that our overloaded operator routine will not alter any class member variables. If you forget to be const-correct in this case, the compiler will bite your head off!

Solution Attempt #2 : Using a priority queue:
We'll use the same class PrioritizedWord from above. That way my lazy self won't have to do much typing. :D

#include <iostream>
#include <string>
#include <queue>  //Instead of vectors, we now use a queue.

//PrioritizedWord Class definition goes here.

int main()
{
std::priority_queue<PrioritizedWord>    wordQueue;

wordQueue.push(PrioritizedWord("Angelo", 23));
wordQueue.push(PrioritizedWord("Here", 51));
wordQueue.push(PrioritizedWord("Was", -1));

//Peek and pop until the priority queue is empty.
while(!wordQueue.empty())
{
  std::cout<<wordQueue.top()<<" ";
  wordQueue.pop();
}

return 0;
}

Note that this time we didn't have to sort anything because the words were pushed into the queue based on their priority. This means that at the end of our input, the words in the priority queue are already sorted based on their weights. Pretty neat, huh? I'd say that in this case a priority queue leads to more elegant code when compared to using a vector. The stuff that I said earlier about being const-correct with regard to the overloaded less-than operator applies here too. The push() function is the one who actually prioritizes the words. Here are some good links to read up on.

SGI Documentation on Priority Queues
Member functions of STL Priority Queue
SGI Documentation on sort algorithm
Enjoy!

More Free Stuff: Open Stickers

2008-03-14T10:18:00.000+05:30

Recently, a friend of mine pointed me to a site that gave free sticker books. You can download them for free, print and use them wherever you like. The theme of the stickers was Open Source. I'm a big supporter of the Open Source philosophy (more on that later). I decided to give my laptop a makeover. Here's what I ended up with:

You can get these cool stickers too!

Free Stuff - Code::Blocks new release

2008-03-09T18:56:00.000+05:30

I've been waiting for this for a long time (nearly two years actually). Code::Blocks 8.02 is here! I mentioned this free C++ IDE in a previous post of mine. At that time, it was called Code::Blocks 1.0 RC2. Now, the developers of Code::Blocks have decided to go with the Ubuntu style of versioning ie; "Year.Month". I must say that this IDE has begun to show much promise. I find it very intuitive and pretty feature-rich (code profiling, code statistics, code-completion and all that jazz) for something that's completely free. The best part, IMHO, is that Code::Blocks is cross-platform. Earlier, it was easy to download and install this IDE for Windows but when it came to Linux you had to configure it from source. They did have some packages targeting specific distributions but many of the links were broken. Now, the Linux packages have been given a face-lift. They even have a Mac OS X binary on the download page. Spiffy!
Interested? Hop on over and give it a try.
Code::Blocks 8.02 Free C++ IDE

Screenshot1: Building and executing a simple SDL application with Code::Blocks 8.02

Screenshot2: An amazing number of project templates for developers from all walks of life.

Screenshot3: Programming doesn't have to be stressful with the BYO Games tetris plugin. There's one for snake as well.

An introduction to the STL : Maps

2008-03-08T02:51:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : std::string, std::vector)
Hello! Today we're going to discuss another popular data structure in the STL - Maps. Maps are basically associative arrays or hash tables where each element consists of a unique key that identifies a particular value. Once a key is stored in the map, then it cannot be changed. Only the value it identifies can be changed. If we want to associate a new key with a value, then the entire element(key + value) must be removed from the map and the new element inserted. To actually see the beauty of maps, let us attempt to solve a simple problem.

The Problem: Write a C++ program to find the character with most number of occurrences in a string.

Solution attempt #1 : Using Vectors

#include <iostream>
#include <string>
#include <vector>

const char VectorMethodOfCounting(const std::string& str)
{
std::vector<unsigned int> vCharCount(26);
char mostUsedChar = '\0';
unsigned int count = 0, currentIndex;

for(std::string::size_type i = 0; i < str.length(); ++i)
{
   //Calculate the index of this character in the vector.
   currentIndex = str[i] - 'a';
   ++vCharCount[currentIndex];

   if(vCharCount[currentIndex] > count)
   {
       mostUsedChar = str[i];
       count = vCharCount[currentIndex];
   }
}

return mostUsedChar;
}

int main()
{
std::string myString = "thebrowncowjumpedoverthemoon";
std::cout<<VectorMethodOfCounting(myString);

return 0;
}

Basically, what we've done here is create a vector for all twenty-six characters in the english alphabet. This vector will maintain a count of the occurrences of each alphabet in our string. Then, we loop through the characters of the string. As we encounter, each character in the string, we determine its index in the vector by subtracting its ASCII value from that of 'a'. We also maintain a record of the character with the most occurrences till date. When we finish iterating through the string, we return this character.
This solution, of course, works but it has some pretty serious drawbacks. The first shortcoming is that it only works with lowercase strings. If the string were to contain uppercase characters or other special characters like spaces, then the solution fails. We could resize the vector to account for all 256 ASCII characters (or maybe all UNICODE characters) but then that would be wasted space if only a handful of characters were actually present in the string. Also, as we will soon see, this problem could have been solved more elegantly. I especially hate that part where we determined the index of the character in the vector.

Now, on to maps. If we analyse the problem more closely, we will come to the conclusion that what we really want to do is maintain a count of the number of occurrences for each character in the string. In other words, each unique character in the string is associated with a count. This concept could best be represented with a map where each element consists of a character as the key and an integer as the value. Let's try doing that.

Solution attempt #2 : Using Maps

#include <iostream>
#include <string>
#include <map>

const char MapMethodOfCounting(const std::string& str)
{
   std::map<char, unsigned int> mapCharCount;
   char mostUsedChar = '\0';
   unsigned int count = 0;

   for(std::string::size_type i = 0; i < str.length(); ++i)
   {
       ++mapCharCount[str[i]];

       if(mapCharCount[str[i]] > count)
       {
           mostUsedChar = str[i];
           count = mapCharCount[str[i]];
       }
   }

   return mostUsedChar;
}

int main()
{
   std::string myString = "thebrowncowjumpedoverthemoon";
   std::cout<<MapMethodOfCounting(myString);

   return 0;
}

A little explanation is in order. In order to use maps, we need to include the pre-compiled header "map". The next thing we do is create a map named mapCharCount. The first char in the syntax is the data type of the keys and the unsigned int is the data type of the values. Everything else is pretty much the same with the exception of the indexing. Unlike our vector method, indexing into the map based on the key is easy. Our key is the character str[i], so we retrieve the value (the count) by mapCharCount[str[i]]. Pure elegance!

There's more to maps than meets the eye. For more information on maps, feel free to read up on the following links:

SGI Documentation on Maps
Member functions of STL Map

In my next post, I'll talk about another STL container - The Priority Queue.

An introduction to the STL : Vectors

2008-03-03T19:22:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : Arrays)
Today I'm going to cover a pretty basic standard library provision that I feel every C++ programmer should know about - Standard Template Library Vectors. Vectors (don't mind the wierd sounding name) are similar to C-style arrays but with more safety. Whenever I explain a concept, I prefer to illustrate what I mean with some code. Let's first try to create a one-dimensional C-style array of type int:

#include <iostream>

int main()
{
    int myArray[3];

    myArray[0] = 10;
    myArray[1] = 20;
    myArray[2] = 30;
    //myArray[3] = 40;    //Can't add any more.

    for(int i = 0; i < 4; ++i)  //Out of bounds!
    {
        std::cout<<myArray[i]<<std::endl;
    }
   
    return 0;
}

One of the biggest drawbacks of C-style arrays is that the dimension(s) of an array must be known at the time of declaration. This generally leads to wastage of allocated space. In our example, we can't add more than 3 integers to the array because we've already decided on its maximum size at compile time.
Another shortcoming of arrays is that its very easy to trip up and access beyond the bounds of an array. In our example, we inadvertently tried to print the value of myArray[3] simply because its quite hard to remember a hard-coded dimension. Of course, there's lots of other ways by which an out-of-bounds access can happen but we'll just stick to the basics for the time being.

Alright then, let's rewrite the exact same code as above, only this time we'll use Vectors.

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myVector;

    myVector.push_back(10);
    myVector.push_back(20);
    myVector.push_back(30);  //Add some more if you like. :)

    for(std::vector<int>::size_type i = 0; i < myVector.size(); ++i)  //Safer...
    {
        std::cout<<myVector[i];
    }
    return 0;
}

At the top we include the pre-compiled header file for using vectors. In main(), we declare a vector of integers called myVector. By default, the initial size of myVector will be zero which means that there is no memory allocated for it. Note that, vectors are also named within the std namespace just as cout is. After we declare the vector, we then add data to this vector using a function named push_back(). Since this is an integer vector, we push integers into the vector. This means that at the end of the three pushes, our vector will be as follows:
myVector[0] = 10;
myVector[1] = 20;
myVector[2] = 30;

However, we couldn't just substitute these statements in place of the three push_back() function calls. Why? Remember that the size of myVector was zero when we declared it. So, trying to access an element of the vector through an index will lead to an out-of-bounds access. Finally, we iterate through all the elements in the vector and display the value of each element. The function size() gives us the number of elements in the vector. So, there's no way we could iterate beyond the bounds of the vector. Now you may ask, what's with that wierd data type with which the variable 'i' was declared? It's nothing but a defined type that is implementation specific for vectors. Since we are iterating over the elements of the vector based on its size, the maximum value of the variable i can be the maximum size for any vector.

There are lots of other cool things one could easily do with vectors. For example, you could resize a vector(doing that with an array would be a major headache) or clear the contents of the vector in one go. Unfortunately, all those cool things are beyond the scope of this measly blog post. The following links should help you get started on STL Vectors:
A Beginner's Tutorial For std::vector, Part 1
Member functions of STL Vector
In my next post, I hope to introduce you to another useful STL container.

const pointers and typedef

2008-02-27T04:26:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : Pointers, typedef, std::vector...)
Sometimes we create our own types using the typedef keyword in C++. For eg;
typedef std::vector<int> INTVECTOR;

If we write : const INTVECTOR myVector;
It is the same as : const std::vector<int> myVector;
This means that the type (in this case, a vector of ints) itself is constant and we can't do stuff like this:
myVector.push_back(10);

Let's look at a typedef for a pointer.
typedef int* INTPTR

If we write : const INTPTR pInt;
Is it equivalent to writing? : const int* pInt;
To answer that we need to think about what these two statements syntactically mean.

In the former statement, we are saying that the type (in this case, the integer pointer) itself is constant and that we can't change it in anyway. That statement prevents us from doing stuff like this: pInt++;

In the second statement, we are informing the compiler that the value that the pointer "points" to is constant.
That means we CAN do : pInt++;
But we can't do : *pInt = 20;

In other words,
const INTPTR pInt; is equivalent to int* const pInt;

Defining a user-defined type within a templated class definition

2008-02-25T09:21:00.000+05:30

(Reader Level : Intermediate)
(Knowledge assumptions : Classes, Templates, Structures...)
Ever tried declaring a class, structure, array or an enum within a templated class? Perhaps, the code could be something like this:

template<class T>
class MyClass
{
public:
    struct MyStruct
    {
        T m_d1, m_d2, m_d3;
    };

    const MyStruct& GetStructure() const;

private:
    MyStruct m_struct;
};

template<class T>
const MyClass<T>::MyStruct& MyClass<T>::GetStructure() const
{
    return m_struct;
}

MyStruct is not a general-purpose structure. It's used primarily for MyClass. So, it makes sense to scope it within MyClass itself. However, this code will not compile. The following errors were reported by the Microsoft Visual Studio 2005 compiler.
warning: 'MyClass::MyStruct' : dependent name is not a type
error: syntax error : missing ';' before '&'
error: missing type specifier - int assumed. Note: C++ does not support default-int
fatal error: unable to recover from previous error(s); stopping compilation

Clearly the cause of this lies in the fact that the compiler can't discern the type of MyStruct in the GetStructure() definition. A look at the standards provides the solution. The relevant citation is from Section 14.6:
"When a qualified-id is intended to refer to a type that is not a member of the current instantiation (14.6.2.1) and its nested-name-specifier depends on a template-parameter (14.6.2), it shall be prefixed by the keyword typename, forming a typename-specifier."

The revised GetStructure() definition for MyClass should be as follows:

template<class T>
const typename MyClass<T>::MyStruct& MyClass<T>::GetStructure() const
{
           return m_struct;
}

The Pimpl pattern

2008-02-12T01:42:00.000+05:30

(Reader Level : Beginner)
(Knowledge assumptions : Classes, Pointers...)
The Private Implementation (Pimpl) pattern allows the implementation of a whole interface without the need to recompile the modules which use it. As with most design patterns, this pattern can best be explained with an example. Let's say that we have a class named Student. Our Student class is very popular in our project because many other classes use it. The header file of the Student class, "Student.h" may be as follows:

#ifndef STUDENT_HEADER
#define STUDENT_HEADER

#include <string>

class Student
{
private:
    std::string m_name;
};

#endif

We may have many classes that contain instances of Student. For example, a Subject class may have an aggregation of Students. So, each of the classes that contain Student(s) would probably have to include "Student.h". Now let's say that at some point in time, colleges allow students to carry mobile phones freely (I know that's not likely. :D). Now, our Student will have a contact number that we might want to record. Professors already had mobiles all along. So, let's say that we already have a class named ContactNo that stores all types of numbers, be they Landline, Mobile or Pagers. "Student.h" becomes...

#ifndef STUDENT_HEADER
#define STUDENT_HEADER

#include <string>
#include "ContactNo.h"

class Student
{
private:
    std::string m_name;
    ContactNo m_contactNo;
};

#endif

After making the relevant changes, we need to do a full re-compile of the source. To our dismay, we might find that the compile time has become unbearably long. Why? It's because we included "Contact.h" in our popular "Student.h". With that one simple change, the header files of all the classes that used to just include "Student.h" will now also include "Contact.h". If our Student was that popular, then this might mean a lot of unnecessary inclusions. To add insult to injury, the contact number of the Student might never even be used by many classes. For example, our Subject class would have no reason to know the contact number of the Students who take that subject. That's why m_contactNo is a private member of Student. You might think that the entire situation is a bit contrived but I assure you its not and there can be situations where you might desperately be seeking a way to reduce compile times, especially in the case of large projects. This is where the Pimpl pattern comes in. Basically, what we need to somehow achieve is the removal of "ContactNo.h" from "Student.h". What we do is take the private implementation of the class (in our case, m_contactNo of Student) and pack it into a simple internal structure. A pointer to this structure, called an opaque pointer or d-pointer is then made a private member of the class. We also need to take care of dynamically creating and destroying the implementation structure for every object of the wrapping class.

This is then our "Student.h" file with the Pimpl pattern.

#ifndef STUDENT_HEADER
#define STUDENT_HEADER

#include <string>

class Student
{
private:
    std::string m_name;
    struct PIMPL; //Forward declaration.
    PIMPL* pimpl; //The opaque pointer.

public:
    Student();
    ~Student();
};

#endif

Our "Student.cpp" file could be:

#include "Student.h"
#include "ContactNo.h"

//Private Implementation structure.
struct Student::PIMPL
{
    ContactNo m_contactNo;
};

Student::Student()
{
    pimpl = new PIMPL;
}

Student::~Student()
{
    if(pimpl)
        delete pimpl;
}

If we want to access the contact number of the student internally we do it as pimpl->m_contactNo. Now that we've seen how useful the Pimpl pattern can be, let's talk about its downside. By using the Pimpl pattern, our code has become a little more complex (less readable anyway) and we've also got to do a dynamic allocation for every instance of Student that is created. For large objects with relatively fewer instances, this probably won't be an issue but for small objects with several instances, Pimpl may not fit the bill.

The stuff Superheroes are made of - Video3.

2008-01-23T20:36:00.000+05:30

And let's wrap it up with the final video. I got the entire series from the Marvel Comics website. I'm sure they'll soon have more videos like these... So you could always check back there.

The stuff Superheroes are made of - Video2.

2008-01-23T20:35:00.000+05:30

Here's the second video of Iron Man's Adventure.

The stuff Superheroes are made of - Video1.

2008-01-23T20:28:00.000+05:30

I'm a great fan of both the Marvel and DC Comic universes. Here are three great videos that might satiate your appetite (or probably not...)

Album recommendation - The Goo Goo Dolls

2008-01-20T20:57:00.000+05:30

Music is a funny thing...Normally, you go out and buy an album because you like one particular song that's been playing over and over on VH1. When you do buy the album, you realise that the rest of the tracks suck (not always). After a little while, even the song that you really liked isn't so nice anymore because its been done to death on TV. That's why its always a good idea to do a little background check on music. There are lots of sites out there that let you preview a 30 seconds of each track before you buy the album. Use this feature. You'll be able to make a better decision. Unless you're a die-hard fan of the artist, always make sure that the tracks measure up to your taste in music.

That said, I have an album recommendation to make. If there's anyone out there who's into Alternative Rock, give The Goo Goo Dolls a listen. I really love this band and one of my favourite albums is Let Love In. I'm not going to write a review on any of the songs simply because one man's symphony is another man's cacophony.

MI isn't Mission Impossible

2008-01-13T08:30:00.001+05:30

I don't want to start a war of ideas on whether Multiple Inheritance is a good thing or not. I know several good programmers who can't get along without multiple inheritance and there are other smart people who feel that multiple inheritance is detrimental to their work. At the end of the day, it comes down to the simple truth that multiple inheritance is not evil in itself, its the way you use it. Sure, it can trip you up in ways you never thought of before but it can also be a very powerful language feature that makes code more elegant and reusable. A while back, I wrote an article on the common "gotchas" with multiple inheritance in C++ and submitted it to Codeguru. Please feel free to read the article here.

Out with the old stuff, Teach the new stuff

2008-01-09T00:12:00.002+05:30

I've always wanted to talk about coding in schools, especially C++. I see many schools and colleges that portray to teach C++, but in reality teach the C-style of coding. I find this approach unacceptable. For example, many courses (even MCA) talk about character arrays when in reality the syllabus should be dealing with std::string. As if that weren't bad enough...

I've also noticed that many educational institutions use archaic compilers for C++ coding. This, in my opinion, is infinitely worse. Even if a student wanted to code correctly, he would not be able to do so. The most commonly used C/C++ compiler is Borland's Turbo C++ 3.0 compiler. This compiler does not conform to the C++ '98 standard. A very simple example of this is the boolean data type which the standards approve of but Turbo C++ does not support it. The truth is that Turbo C++ is an obsolete compiler and Borland themselves do not work on it anymore. Continuing to use such a compiler will ensure that you never learn anything that is industry standard. There are quite a few non-commercial compilers that are standards compliant.
1. The MinGW (Minimalistic GNU for Windows) compiler for Windows.
2. GCC (GNU Compiler Collection) for almost every platform.

If you are a student and don't want the hassle of bothering to download and configure a particular compiler for your IDE, then I recommend these IDEs:
1. Microsoft Visual Studio Express Edition
Its the most professional free IDE out there. Of course, it only works under Windows and comes with the Microsoft Compiler.
2. Code::Blocks
I really love this IDE and the best part is that it works on Windows, Linux and now even the Mac OS. It also supports a variety of compilers.
3. Bloodshed Dev C++ 5.0
A great IDE for students. It comes in two flavours - one with the MinGW compiler and another without any compiler. Dev C++ is also exclusively for Windows.
4. Geany
Geany is a newcomer to the scene and I've really noted it for supporting several languages and being extremely light-weight. Geany is also being actively developed for multiple OS platforms.
5. Finally, if you work on Linux, I recommend either KDevelop or Anjuta. I now use Code::Blocks as a standard IDE for both Windows and Linux, though.

If you're going to do stuff, then you have to do it right.

Start Stuff

2008-01-07T07:58:00.001+05:30

Hi all! I've been deliberating for some time on whether I should start a blog or not. I guess I've got stuff to talk about and so I've finally taken the plunge. Here's the Disclaimer : "Nothing I've got to say is earth-shattering. Read at your own risk!" First, a little about myself. I am a student pursuing my Master's Degree in Computer Applications which I am due to complete in a few months. As you might have suspected, I am interested in tech talk. That's not the only stuff that I will talk about, though. I love listening to music and once in a while I will try to suggest and maybe even do a review on a good music album. The main reason as to why I've started this blog is so that I can share ideas and information. A lot of my time is spent in coding and I find out nifty tricks or read about such tricks elsewhere. I also come across coding bugs and perhaps if I post solutions to common problems other programmers could benefit from them. I also want to share my views on certain issues in the digital world (Read as : "I want to start a rant"). I play plenty of PC-based games and maybe once in a while I could talk about some of the games that I play. Of course, I welcome comments. If you find some error in a post of mine or just want to chip in with your view, go ahead. The world will be the better for it. Alright then. After all that's been said, let's start doing stuff.