Home

Ok, so I'm a little behind the times. Amazon's Affiliate Program has been around for a while--since 1996 to be exact. Everyone and their grandma must have an account by now, making millions off sales of "The Secret" that they linked to on their blog (this is actually the secret that the book talks about). But incase you happen to be Amish, here's a short tutorial on the whole process of signing up for an account and building affiliate links.

1. Visit https://affiliate-program.amazon.com/ and click the "Join now for FREE!" button. It requires that you create an Amazon account first if you don't already have one.



2. It then asks you for your contact information and has some questions about the website/blog where you'll be putting your affiliate links.



3. And that's all the information they need to get your account set up. You don't even have to submit your payment information (although, you'll want to do this eventually...after all, making a few bucks is why you're here, right?). As you can see in the screenshot, Amazon assigns you a unique "Associates ID". This important identifier will be stuffed into all the affiliate URLs you create so that Amazon knows who give money to when a sale is made. To start making links, click the "Learn More" link in the "Product Links" box.



4. It's really easy to create affiliate links. It just takes a few clicks of the mouse and some copy and pasting. First, search for the product you want to link to. I chose a book I recently read.



5. Next, find the product in the search results and click the "Get Link" button.



6. This will take you to the page that lets you build your link. There's a lot of options here you can play with, so take some time to explore this page on your own. Once you're done crafting the link to your liking, copy the HTML code in the "step 3" box and paste it on your site. It's no secret--it's that simple!

I recently redesigned my website and one thing I changed was putting my blog on the front page instead of just linking to it. But what's cool (at least, according to my own geeky tastes) is that my blog is hosted on Blogger--not on my website! In this post, I'm going to walk through how I did this.

1. Blogger setup
First, you need to make sure your Blogger feeds are configured to include the full content of each blog post (as opposed to just the first paragraph or whatever). I think this is the default setting, but to make sure, to go the Settings page and click on the "Site Feed" tab. The "Allow Blog Feeds" option should be set to "Full".



2. Atom feed URL
Now, you must get the URL of your blog's Atom feed. Go to your blog's homepage and view the source (in Firefox, this is under "View > Page Source"). Look for a "link" tag that looks like the one below, and grab the value of its "href" attribute.

<link rel="alternate" type="application/atom+xml" title="mangstacular - Atom" href="http://mangstacular.blogspot.com/feeds/posts/default" />



3. Magpie setup
Download Magpie. This is a wonderfully easy-to-use RSS/Atom parser written in PHP which we'll use to parse the Atom feed.

You'll want to configure Magpie to cache the Atom feed so that it only downloads it when your blog changes in some way (i.e. when there's a new post or a new comment). This way, your website won't have to download the feed from Blogger every time someone visits your page. Open the "rss_fetch.inc" file and add these two lines somewhere at the top:

define('MAGPIE_CACHE_ON', true);
define('MAGPIE_CACHE_DIR', 'cache');

This will turn on caching and instruct Magpie to save the cached Atom file in the directory you specify.



4. Parse the Feed
Now you're ready to write the code that fetches and parses the feed. Simply calling Magpie's "fetch_rss" function will parse the feed and return all the data in an associative array (despite "rss" being in the function name, it will also parse Atom feeds). No need to deal with any XML. Below is some sample code.

require_once('magpierss/rss_fetch.inc');

$atom = fetch_rss('http://mangstacular.blogspot.com/feeds/posts/default');
foreach ($atom->items as $item){
  //var_dump($item); //see all the stuff that's in each item

  $date = date('F j, Y', strtotime($item['published']));
  $title = $item['title'];
  $content = $item['atom_content']; //no need to run html_entity_decode() or anything
  $url = $item['link'];

  //because there are two <link> tags whose "rel" attributes are the same...
  //...it stuffs the "href" attributes from both tags into this one string...
  //...so you must extract the URL you want...
  //...which in my case is the URL to the comments page
  $commentsUrl = substr($item['link_replies'], strpos($item['link_replies'], 'https'));

  $numberOfComments = $item['thr']['total'];

  //generate HTML for the entry
  //...
}

And now it looks like you're running fancy Wordpress software! ;)

Ever since I started my new job, I've gotten into the habit of turning on the morning news while getting ready for work in the morning. They do reports on rush-hour traffic and this morning, there was one whopper of an accident. A tractor-trailer had slide-lined three cars, completely blocking the flow of traffic in that direction. It was on a road I take everyday to work, but I wasn't sure exactly where on the road it was, so didn't know if it would impact my commute.



Then, I remembered that Google Maps has a live traffic feature that overlays the amount of traffic congestion on the map. I could see where the congestion was and figure out if I needed to find an alternate route. Oddly enough, it reported all roads as being more or less clear, which I knew was not the case. The roadside webcams (another Google Maps overlay) also didn't show any signs of an accident.

It turns out that the data just isn't very "live" after all. Not only was the traffic overlay not reporting the current traffic situation, but the webcam images weren't current either--they were anywhere from 30-60 minutes old. Clicking on the image takes you to the website that operates the webcams, and only going there can you get an up-to-the-minute view of traffic.

So it turned out that my drive wasn't affected. And I learned that, while the traffic overlay on Google Maps is great for seeing general traffic trends, it's not so good for live traffic updates.

I just finished making improvements to a PHP/MySQL-powered photo gallery website I had written during college (it kind of felt good to see how much my coding skills have improved since then). Besides moving all the SQL into a DAO, cleaning up the UI, and learning how to do file uploads in PHP, I went through all the code and formally documented all the functions and classes. I decided to use phpDocumentor because the format it requires the comments to be in is nearly identical to Java's Javadoc, which I was already familiar with.

I wanted to set up an Ant target that I could run that would generate the HTML documentation. It was pretty straight-forward--just create a target using the Exec task to run a console command. However, even though I could call the "phpdoc" command straight from the command line, Ant had problems with that. I think this is because "phpdoc" is not an executable, but a PHP script. At any rate, it worked fine once I found the script that the command was linked to and used the "php" command to run the script.

<target name="phpdocs" description="Generates phpDocumentor docs">
  <delete dir="${doc.dir}" />
  <exec executable="php">
    <arg value="/usr/local/PEAR/PhpDocumentor/phpDocumentor/phpdoc.inc" />
    <arg value="-f" />
    <arg value="*.php" />
    <arg value="-t" />
    <arg value="${doc.dir}" />
    <arg value="-ti" />
    <arg value="Photo Gallery Documentation" />
  </exec>
</target>

I recently read the book A Programmer's Guide to Java SCJP
Certification: A Comprehensive Primer (Third Edition) by Khalid Mughal and Rolf Rasmussen in order to prepare for the SCJP exam (which I took and passed last week). I sent the authors of list of mistakes that I found and some have made it into the book's online errata!



How cool is that! :-P

Sorry, I need to rant a little. >:(

OpenOffice isn't as great as everyone says it is. Or at least as great as I though it was. I'm looking for a job and have been using the open source office suite to update my resume. Most recruiters want resumes in Microsoft Word's ".doc" format, but have no fear! OpenOffice supports that format...

...mostly...sorta kinda.

My resume is pretty basic in terms of features used. It uses two tables, a few bulleted lists, and three drawn lines, along with text of various sizes and fonts. But apparently that's too complex. It can never quite seem to get the bullets in the bulleted lists right:



One time, it used an icon of those things used in movies at the start of a take. Just completely random.

For throw-away documents, this is bearable. But for something important like a resume, you want your .doc to come out exactly right. And OpenOffice fails to do this.

If you're familiar with both Netbeans and Eclipse, you'll probably know of one obvious difference which sets the two apart: Eclipse supports "workspaces", while Netbeans does not (or at least, doesn't appear to--read on). A workspace is sort of like the "state" of the IDE--it's a collection of open project folders and IDE settings. Workspaces are useful when you are working on two unrelated projects which use different code and require the IDE to be configured differently.

By default, Netbeans only allows you to have one workspace. That is, when you exit Netbeans, all your open projects and settings will be restored when it is launched again. This is different from Eclipse, which asks you to specify a workspace every time it is launched. There is a way to specify your workspace with Netbeans as well, though it's not through an easy-to-use UI. An extra parameter must be included when invoking the Netbeans executable:

--userdir C:\path\to\workspace

Here is how to do use this parameter in Windows:

1. Create a shortcut on your desktop to the Netbeans executable: C:\Program Files\NetBeans x.x\bin\netbeans.exe.


2. Right-click on the shortcut and click "Properties".


3. In the "Target" textbox, add the extra parameter to the very end:
   
   --userdir C:\path\to\new_workspace


4. Click "OK" to exit the Properties window and double click the shortcut. Netbeans will launch and create/load the workspace at that location.

Tip: I like to use my default workspace as a "jumping-off point" for all my new workspaces. This saves me time I would otherwise have to spend resetting all my IDE settings, like SVN and code formatting preferences. Just make a copy of the default workspace folder and create a shortcut pointing to that folder, as shown above. The default workspace is located here:

~/.netbeans/<version>

There was a power outage in my apartment building the other day, so I went to reset the clock on my stove.

Instead of making you select the hour and minute in two separate steps like most appliances do, you do it in just one. Press the up/down buttons once, and the clock will increment/decrement by one minute. Hold the buttons down, and it moves in ten minute steps for as long as it's pressed.

I thought that was kind of clever. It keeps the task of "Setting the Time" consolidated into a single step, as opposed to breaking it up into as many as three (setting the hour, minute, and am/pm).

Want to see something that will blow your mind? Something that will shoot your brain out the back of your skull, through the window, and onto your neighbor's freshly waxed Pinto?

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="layout/frontpage.xsl"?>
<page lang="en_us">
  <frontpage/>
</page>

This is the source code for a website's entire home page (which is that of the upcoming computer game Starcraft 2 by Blizzard Entertainment).

I could be in the minority, but I've never seen XSLT used to transform XML documents into web pages...and I've never realized how powerful it can be. After exploring the source code of the website, here are some advantages and disadvantages of this technique that I've discovered:


Using XSLT, you can more effectively separate the content of your website from the presentation. The Starcraft 2 website has *all* of its text separated out into XML files (pretty cool!). For example, you can find all the text on the Terran page, in a file devoted solely to storing Terran-related text (terran.xml).


By separating the content from the presentation, another benefit is that it makes it easy to internationalize the website. This is what Blizzard has done. The XML files used to store text are located in their own directory, named according to the language of the text (such as "fr_fr" for French). The language of the guy viewing the website is stored in the "lang" attribute of "page" tag of each individual web page (see the above code snippet). This attribute is used to determine which directory to retrieve the text from.

Also, you can do things that you would normally think could only be done using server-side languages:


Since XSLT uses the XPath language, you get to use all the special functions that XPath comes with. Tasks like string manipulation, date/time formatting, rounding numbers--all things that one might typically associate only with server-side languages, can all be done with XPath. For example, the following code, taken from a shared file called includes.xsl, uses the "concat" function to build a URI that points to a language-specific version of an XML file:

<xsl:variable name="terran" select="document(concat('/strings/',$lang,'/terran.xml'))"/>

Just as you might define a function in a server-side script that performs some task, you can define function-like constructs with XSLT that "output" HTML. If you look at movies.xsl (a file used to generate the Movies page) you can see that for each movie listed on the page, a template is called:

<xsl:call-template name="movies-entry">
 <xsl:with-param name="title" select="$loc/strs/str[@id='sc2.labels.movies.movie6.title']"/>
 <xsl:with-param name="movieid" select="'6'"/>
 ... more parameters ...
</xsl:call-template>

The template, defined in a shared file called includes.xsl, contains the HTML code used to display the movie:

<xsl:template name="movies-entry">
 <xsl:param name="title"/>
 <xsl:param name="movieid"/>
 ... more parameters ...
 ... HTML/XSL code used to display the movie ...
</xsl:template>

So instead of having to do a lot of copying and pasting, as you would have to do if using plain HTML, the code stays centralized in one place, making bug fixes and other maintenance tasks easier to handle.


XSLT didn't become a W3C recommendation until 1999, so any browser created before or around that time probably won't have strong support for the language (this includes IE 5 and earlier). So you have to consider the software your audience is likely to be using before building your site. Blizzard probably thought it safe to use this technology, since gamers tend to use the latest and greatest browsers and are therefore unlikely to run into any compatibility issues.

So in conclusion, I've found that using XSLT to build web sites gives you many advantages that you don't get when developing with vanilla HTML. Perhaps I will use it for my next web development project!

I've developed a bit of an addiction recently. Thankfully, it's not alcohol-related. But like drinking, it does take up time and money.

If you're not familiar with the puzzle game Sudoku, you've probably at least seen it either in your daily newspaper or somewhere online. The goal is: given a square board 9 cells high and 9 cells wide, fill each row, column, and 3 by 3 sub-square with all the numbers 1 through 9. No number can be repeated in any of those three places. For example, the number 5 can't appear more than once in the same row. The board starts with some cells already filled in to give you a starting point. The less completed cells you start with, the harder the puzzle is.



After solving enough of these, I thought it would be an interesting exercise to write a program which solves them automatically! As I got deep into creating the algorithm, one data structure stood out as being the keystone--sets.

In mathematics, a set is a collection of numbers where:

1. the order the numbers are in does not matter and


2. no number can be repeated.

For example, this is a set:
{ 3, 7, 5, 9 }

Since order doesn't matter, this is the same set as the one above:
{ 9, 3, 7, 5 }

But this is NOT a set because there are two 7s:
{ 9, 3, 7, 5, 7 }

In this algorithm, sets are useful when trying to figure out what number a cell should be. The algorithm can be summarized with this pseudo-code:

while board is not complete
  for each cell in board
    if cell is empty
      possibleValues = findPossibleValues(cell)
      if size of possibleValues == 1
        cell.empty = false
        cell.value = possibleValues[0];

function findPossibleValues(cell)
  possibleValues = new set{1,2,3,4,5,6,7,8,9}

  for each rowcell in cell's row
    if rowcell is not empty
      //if possibleValues doesn't contain rowcell.value, then nothing happens
      possibleValues -= rowcell.value

  for each colcell in cell's column
    if colcell is not empty
      possibleValues -= colcell.value

  for each squarecell in cell's square
    if squarecell is not empty
      possibleValues -= squarecell.value

  return possibleValues 

Given a current board state, for each cell in the board, a set containing all values the cell could possibly be is created. If this set only contains one number, then that's the only number the cell can be, so we fill in the cell with that number. This keeps repeating until all cells are filled in. (There are some other tricks that have to be taken into account, but this is the most fundamental part of the algorithm.)

If you'd like to try it out or look at the source code, you can download it here:

http://www.mangst.com/projects/sudoku-solver

Somewhere, deep in the bowels of a florescent-lit cubical farm, a battle wages on. A battle that has been fought since the dawn of computer programming. A battle of..."right vs. right"?

This sums up the approach that Michael Lopp, better known as "Rands" in the blogosphere, takes to software engineering. In his book Managing Humans: Biting and Humorous Tales of a Software Engineering Manager, the battle he describes is one of Incrementalists vs. Completionists--those who want to get things done quickly verses those who want to get things done correctly. Both mindsets are equally "right" in Lopp's eyes. It's the balanced combination of the two that makes for a solid software team.

Lopp takes this even-handed, "ying/yang" approach throughout his book, which is mostly made up of posts from his blog, Rands in Repose. As with the incrementalists and completionlists, his characterizations of office personality types are colorful, insightful, and even-handed. In the chapter entitled Meeting Creatures, Lopp takes you on a wild safari, describing the different kinds of people you'll encounter around the conference table at work. These meetings, he describes, are a rich ecosystem made up of unique, but interdependent personalities. You never have any idea what a "Curveball Kurt" is talking about, for example, which is why you need a "Translator Tim" to help out.

In regards to writing style, each one of the short, thirty-four chapters are written in a light, conversational tone that's easy to digest. Being a collection of blog posts, it's easy to pick up and put down without getting involved like you might with a novel.

So, the book is great, but it should be noted that people may find it hard to relate to some of Lopp's stories. Lopp works in the fast-paced, high-energy Silicon Valley, where startups come and go like contestants on American Idol. This can make for some quite stressful times. He talks, for example, about The Monday Freakout which describes the deluge of yelling and screaming that comes pouring out of a project lead after a weekend spent worrying about the project. I think it's safe to say that not everyone works in an atmosphere like this. Many readers may have a job that, while engaging, doesn't keep them stressing over the weekend.

But the bottom line is that no matter where you work, if your job is somehow related to software development, you can learn something from this book. Read on! It's the "right" thing to do.

I just recently finished putting together a small utility I had written a while ago for some websites I had designed during college. I spent a few days cleaning it up and turning it into something generic that anyone could download and start using right away. I've called it...**drumroll**

ThumbThru

It's a simple photo gallery utility coded entirely in Javascript and written in such a way so that it takes as little time as possible to get up and running. It's a lot like the galleries you'll find on the In Pictures section of the BBC News website--in fact, you could say that's where I got my "inspiration".

Some things I learned when writing this:

• How to create a Javascript class


• The difference between the GPL and the LGPL (I've licensed it under the LGPL, btw)


• The fact that Ant can create ZIP files (pretty cool!)

All future blog posts perhaps...?

Anyway, feel free to download ThumbThru and give it a try! Or at least check out the live demo!

So, I go to check my Gmail account like I do on a regular basis. But when I logged in, I noticed something different.

There was this red bar above my inbox:



It turns out that I did indeed have Firebug (a Firefox extension) enabled! And I wouldn't have known it otherwise. Google probably decided to include this feature after getting complaints from users who didn't realize that it was their own stupid fault their mail was loading slowly. Or maybe Google decided to include it out of the kindness of their hearts. Either way, it's pretty cool to see a huge corporation that certainly doesn't need do something like this, take the time to do it. They could have buried the issue somewhere deep inside a FAQ page and left it at that.

In the short-term, spending time to include something that only benefits a small minority of users a small minority of the time is a waste of money. Some developer might have spent a day designing this feature. Google's stock price certainly won't rise the next day because of it. He should have been working on Adsense or something!

But it's the longer term impact that is affected by small enhancements like this. What this is saying isn't "turn off Firebug". It's saying "I know you want to get to your email quickly and Firebug may interfere with that." Or more simply:

"I understand you."

When another product of equal or better quality comes around, if you've been regularly reminding your users that you understand them, they'll be more likely to stick with you during tough times.

For the longest time, the iTunes music store has pretty much dominated the music download market. Apple's service has a gigantic selection of music to choose from and they make it super easy to find that song you want to hear. But there's one downside to all this: most of the songs are protected by digital rights management or DRM. This puts limits on things like on what devices the songs will play and how many times a song can be copied. A song without these limitations is certainly a better deal for the customer, who can instead copy the song to as many devices as he desires and play the song on all of them.

Amazon, traditionally the book-selling behemoth of the interwebs, fairly recently started providing music for download. While it doesn't have the extensive selection iTunes is known for, all of Amazon's music is DRM free and encoded in the generic MP3 file format, giving you more freedom over how you can use the music you paid for.

Just today, I downloaded my first album off of this service. It was a pretty painless procedure, though there's a few things you should be aware of:

One - If you want to purchase an entire album, you've got to download this special "Amazon MP3 Downloader" software. It's always annoying when you have to install an entire application to do something as simple as downloading a couple of files. But one feature that takes the edge off of this inconvenience is that it automatically puts a copy of your songs in either your iTunes or Media Player (depending on your OS) library, saving you the small, but sometimes tedious, step of organizing your music by hand.

Two - They have no refund policy. Once your credit card is charged, there's no way to get your money back. Makes sense, since the product you're paying for can't get damaged the way it could if sent through the mail.

Three - You can only download your songs once. If your hard drive decides to stop working one day, that's it, they're gone. You can't download them again without paying a second time. While it doesn't take much effort on your part to make a backup, this still seems like a silly policy. Because the music is DRM-free and can be copied ad infinitum, it seems that what you're really paying for is permission to play the music, as opposed to the music itself.

This is what I like to think of Valve's Steam doing. Steam charges for downloadable content just like Amazon and iTunes does, only instead of charging for downloadable music, it charges for downloadable computer games. Since Steam lets you download the games you've paid for as many times as you want, it's charging you for permission to play the game--not necessarily the game itself. I don't see why Amazon couldn't implement a scheme like this as well.

In conclusion, despite the software it forces down your throat and the one time download limitation, I do indeed recommend Amazon's music download service. Its policy of providing DRM-free music for purchase is something that would be nice see amongst the larger music sellers. Always search Amazon for that song you want before looking anywhere else. DRM-free is the way to be!

In light of the up and coming (at the time) Pennsylvania Democratic primaries, I was asked by my alma mater's student Democrat organization to create a website for their group. I thought this would be a great opportunity to give an open source CMS (content management system) a try. I ended up choosing Drupal and was able to get it up and running with relative ease. To my surprise (and frustration), only a week later, the Drupal developers released a new version, compelling me to upgrade. In this post, I'm going to talk a bit about the Drupal upgrade process and upgrade processes in general.

Upgrading Drupal, or any application for that matter, is often much harder than performing an installation from scratch. Two major hurtles come to mind.

(1) Compatibility. Will all your stuff still work with the new version?

When Microsoft releases a new version of their Office suite, for example, you want to know that *all* your Word documents created by previous versions can still be opened.

Drupal, unfortunately, doesn't make things that convenient. In the cosmic balance between the software pragmatists and the software idealists, the Drupal team, unlike Microsoft, fights for the idealists. Any time they release a new "major" version (that is, 5.x to 6.0, for example), they pretty much guarantee that all existing custom themes or modules will *not* work. This is because they are very much willing to throw away a large part of the codebase if they think there's a better way of doing something.

These compatibility issues, however, are not an issue with "minor" upgrades (such moving from 5.4 to 5.5). This is because minor upgrades usually deal with security fixes and implementation details that your custom modules and themes don't care much about. Luckily, the upgrade I wanted to perform, 6.1 to 6.2, was a minor upgrade, so I knew with a high degree of confidence that all my custom themes and modules would still work (and they do).

(2) Data preservation. Will any of your data be lost in the upgrade process?

Of course, you want this answer to be a resounding "NO WAY!". For example, if you upgrade to a new version of Firefox, you don't want to load up your new version, only to find that all your bookmarks are gone.

In Drupal's case, this means not loosing your custom themes, custom modules, site content, and files your users uploaded. What makes this a bit complicated when upgrading Drupal is that the Drupal team recommends you completely remove all files from your existing Drupal installation and then do a fresh copy of all the files from the new version (as opposed to just overwriting everything). This means that you must be aware of all the ways in which your Drupal installation differs from the "base" or "initial" installation. That is, you must know about your custom themes, custom modules, etc. so you can put them back after you've copied over the new version.

I find it helpful to maintain a list of all of these differences. That way, whenever I have to upgrade, I know exactly what files to put back into the new version to keep my site running smoothly.

Now that you've got an overview of what to expect from your Drupal upgrade, you might want to do some reading on the Drupal website for more of the technical details. Good luck!