I’m a bit of an information pack rat. When I have an idea or something I need to keep track of, I have an immediate need to write it down or record it. In the past this has resulted in an assortment of post-it notes, notebooks or even loose papers lying around my desk, all used to document my thoughts. Eventually, I tried to move my note-taking over to the PC in an attempt to make it easier to manage, but over time the notes became spread over a variety of formats and storage mediums, from text files on my local PC to online services such as Google Calendar and Dropbox.

This sort of digital storage Balkanization was becoming a nightmare to manage and effectively neutralizing any benefit from taking notes, since finding and keeping track of what I’d written down was becoming a chore by itself. Clearly, a unified solution was needed. Ever since I got my iPhone last year, I’d been looking for an app or service that would allow me to easily keep track of todo and shopping lists (what most of my notes amounted to), while storing the the data online so that it could be synced or updated from my PC as well.

I think I’ve finally found that with Awesome Note.

What I was looking for

As mentioned, I love keeping lists. So what I needed was an app that could allow me to easily keep track of lists as well as allow me to backup or sync the underlying data in such a way that I could also work with the lists on my PC or online. The built-in Notes app didn’t meet my needs because you could only sync it with certain supported software, such as Outlook, which I didn’t use or care to use at home.

Browsing through the App Store was almost an exercise in futility. Trying to find a decent note-taking app (or any app, for that matter) is a time-consuming activity; I didn’t want to shell out any money without being able to first try the app out, so many apps were immediately ruled out.

The first one I tried was one aptly named Lists. While it was functional and had support for lists and lists-within-lists, it was buggy and the UI left a lot to be desired. The next one I tried was Evernote’s app; while Evernote is a nice service, the iPhone app left a lot to be desired. While the web application or the PC software allowed you to take all sorts of notes, only basic editing functionality was available on the app, and it was suited for a more general note-taking approach rather than one for lists and the like.

I stumbled upon the free version of Awesome Note soon after, which thankfully was fully-featured but limited you to only a few notes. Nonetheless, I was immediately impressed.

Just felt right

Right off the bat, I was impressed by how easy it was to create a list and add items. When creating an item, you can use the “quick-add” functionality that allows you to nicely add a new item while staying on the same screen; if necessary you can later add a longer description on a separate screen. Furthermore, it’s easy to sort items by date, name or priority; more importantly, there’s a robust search function as well. Swipe-to-delete functionality is also nicely handled.

You can create multiple folders, each to store separate items, for example, a shopping list and a todo list. Each folder has its own view options, either thumbnail, lists or todo view, store separately so you can sort through different lists in different ways, each remembered by the app. Furthermore, it’s easy to convert an item to a todo item; you simply tap a box next to an item to change its state from done/not done and there’s no need to navigate complicated setup screens to change this.

There’s also a “Quick Memo” feature, which gives you a notepad to quickly jot down ideas that you can later convert into a fully-fledged note or item. It basically replicates the functionality of the built-in Notes app, all while providing some other nice features such as adjustable fonts, just like the rest of the app.

Furthermore, the UI was very polished; each folder can be identified by colour and an icon of your choosing. A nice assortment of these icons/backgrounds is provided, all of them looking great. In short, everything looks very well refined and well thought out, making list and note management very easy.

But most importantly, the sync worked great out of the box. I tied it to my Evernote account, and as a result I now have the unified access to my notes that I so badly wanted. I’d previously used Dropbox or even my own SVN server to get some semblance of cloud-based storage and access to my notes, but but neither was sufficient to properly work with my iPhone. Awesome Note now provides that functionality, with a great UI/front-end making list/note management a breeze.

I strongly recommend giving it a try if you find yourself using your iPhone/iPod Touch to take notes.

Back on November 2nd, the City of Toronto launched their toronto.ca/open service – a project aimed to be the “official data set catalogue” of the city. Part of the OpenTO initiative to make various data that the city has collected available to developers in formats that make them easy to manipulate, toronto.ca/open is the first step to making the city and its services more “open and accessible”.

The hope is that if the city makes this information available in a readily-usable form, developers will take the time to create various services around them, helping citizens enjoy and take advantage of what Toronto has to offer. For example, data on garbage collection, public transit or upcoming city events could be used to create a service that would alert users through various means of communication. But at present, the amount and types of data available are fairly limited.

Announced back in April at the Mesh Conference in Toronto by Mayor David Miller, the openness initiative had a lot to live up to in the half-year following up to its release earlier this month at the Toronto Innovation Showcase.

Several cities have already implemented similar projects, leaving Toronto to play catch-up. Vancouver, for example, launched their own Open Data initiative earlier this year, and Toronto’s data catalogue appears to be modeled after it. Edmonton, a much smaller and less dense city than Toronto, has also recently begun an initiative to open their city’s data to the public in a similar manner, with promising results.

But the data is better late than never, so I applaud the City’s effort to democratize and help keep citizens better informed.

The data itself

Looking at what’s offered, you can see that most of the data sets or services have a geographical component to them. This only makes sense, as hyperlocal information is always of great interest to most people.

The data is presented in a variety of formats, but the most popular seems to be an ESRI Shapefile, a file format used by a popular suite of GIS software. With much of the data having a geospatial aspect to them, this makes sense as the data likely didn’t require much conversion before being released by the City. (I.E., they probably use ESRI’s application for city planning, etc.)

Thankfully, the format has been well-documented by its developer, and Wikipedia as well. All of these ESRI Shapefiles are intended to be downloaded for offline use, as they are typically made available inside of a zip file. Thus, the process of keeping them up to date may prove tedious, though I’m sure an enterprising developer could automate it nicely.

Other data has been made available in various XML formats. Some are intended to be accessed as online services, with a link to the XML document and the corresponding XSD file, while at least one is presumably meant to be used offline since it’s zipped up. Some of the XML “Feeds” are also in a format without a defined schema and are not RSS or Atom feeds. For example, the feed of City-sponsored events would be better served by an RSS or Atom feed, which would not only allow developers to integrate it into an application, but also regular users to sign up to the feed using any newsreader.

There are also some web services explicitly offered. The first is a geocoder service that can be used to validate addresses and other place names within the City. It is a WSDL service, and there is a full PDF file to document the input parameters and expected output.

The second is a series of services that provide access to “live geospatial data from the City of Toronto“. These are all Web Map Services that conform to a protocol specification developed by the Open Geospatial Consortium. It would have been nice if they had linked to the WMS Specification (PDF document) that explained how to query the services, instead of forcing you to find out the information yourself. (See page 14 and onwards of the mentioned document)

Lastly, some of the data is offered in plain old text files. In particular, the TTC Routes and Schedules is only available as a series of zipped text files that are periodically updated, presumably manually. This may be a bit backwards, but thankfully the formatting is well-defined.

Drawbacks

Though it may not be fair to criticize at this point, there are some clear limitations to the data. Firstly, much of the data is intended to be downloaded and then used in an “offline” capacity, that is, without further communication between the application and the City’s servers that host the data. Though this was probably done due to technical limitations (i.e. reducing bandwidth usage), it limits the ability of an application to stay up to date with the latest data. For things like the TTC Route and Schedules and the list of Apartment Bylaw Infractions, this severely reduced their effectiveness as the data will likely need to be periodically manually updated.

Furthermore, the current data set is somewhat limited and may impede the usefulness of any applications or services that can be developed. For example, making real-time TTC updates and other data available would be an immense benefit, yet the only TTC data currently available are in zipped text files that are only periodically updated. Thankfully, the City has setup a site to allow users to request more data, and there are already many requests for more TTC data.

It would also be nice if crime statistics for Toronto could be made available in an easy to use format. In particular, the underlying data used by the TPS to produce their crime maps and statistics could be beneficial in developing all sorts of interesting maps. In fact, this is what the Toronto Star has been doing for some time, but they had to get the data through an explicit request under access-to-information legislation. Since then, they’ve produced some very interesting maps and it would be beneficial if everyone had access to the same data so that the maps could be improved upon and kept up to date.

Producing such crime-based maps can provide people with one more factor to help them determine what part of the City they’d like to live in, or just allow them to have access to accurate statistics on crime. Not all of this is negative – as any study of crime in Toronto will show that it’s been following a downward trend for quite some time, so such information could help ward off any potential negative spin that media may put on crime. However, I do realize the privacy implications that come with releasing such data, so time should be taken to ensure that it is released in a manner where anonymity is preserved as best as possible.

Lastly, it’s important to note that the OpenTO initiative is still at a very early stage. Even with the way things move at City Hall, things will eventually improve. It’s also very important to give your feedback, either at DataTO or directly by email to opendata@toronto.ca. Additionally, if you’re a developer, the corresponding Google Group is a good place to get started. Even with the current limitations, I am sure we’ll see some great applications developed based on the data. One need only to look at MyTTC to see what can be done with some effort and ingenuity – and this was done well before the City officially released any data!

After much delay, possibly due to government meddling, Google Street View finally went live in select Canadian cities last week! Most of the GTA is covered, along with Kitchener/Waterloo, Ottawa, Montreal, Quebec City, Halifax, Calgary and Vancouver. This likely ensures coverage for a majority of Canada’s population, if only a very small minority of its geographical area.

This is a welcome move, since street view has been available for our neighbours to the south for the past two years.

According to some reports, Street View was supposed to launch in Canada earlier this year, and some of the imagery was collected as early as 2007. (Though the images around my area seem to be from early this year) Oh well, this is better late than never!

I’m speculating that the government’s concern with Google Street View may have slowed deployment, as in 2007 the privacy commissioner voiced strong concerns against the technology. I’ve never believed any of that FUD, but it seems that their concerns have been addressed with Google’s automatic detection and blurring of faces and license plates, along with new straightforwards processes to request that your image be removed from the service.

But it’s still been much ado about nothing, not really like the conflict between the government and Facebook earlier this year, which was also subsequently resolved. In the case with Facebook, privacy settings were often complicated and unclear; with Google Street view, they’re merely providing public views of public places, so I don’t see what the problem with that is.

Also available on the iPhone/iPod Touch

You can also use Street View on the built in Maps app for the iPhone OS, though it’s a bit convoluted since there’s no “Street View” button to toggle. Instead, you must first drop a pin (click on the “layer peel back” icon in the lower right corner) and then bring up the dialog box for that pin. If it’s in an area with Street View present, the little guy icon on the left will be lit up and you should be able to click it to bring up Street View.

Street View only works in landscape mode but it’s still pretty useful for getting to know an area before you visit it for the first time. Sometimes an actual image can convey sense better than just a map.

Competition?

It remains to be seen how the launch of Street View in Canada will fare for the similar service launched by Canpages in BC. That service only covers Vancouver, Whistler and Squamish but was launched back in March.

Nonetheless, it’s very neat technology, even if it was originally unveiled over two years ago. Witness this by the fact that reporters are still drooling over it by embedding the service in every article covering the launch.

Well, I finally gave in and joined the cult of iPhone. At the beginning of this month, I decided to splurge and get an iPhone through Fido, Rogers discount brand. Why? I suppose it had something to do with the extension of the 6GB/$30 “promotion” or the fact that I was able to find a 3GS for sale locally, but mostly it had to do with the fact that I needed a new toy. (Note that the iPhone is hardly a novelty item, with >21 million of them out there)

Keep in mind that I didn’t have a mobile phone until late 2007, and even then I decided to only go with a prepaid provider (Virgin Mobile) because I didn’t have much of a need for a phone, but really just wanted Internet access. However, this past summer my phone got more use than usual, especially with regard to Internet access. With Internet browsing being anemic on most non-smartphones, I decided it was time to upgrade.

I narrowed my choices down to two: Either the Palm Pre or the iPhone 3GS. However, I wasn’t very pleased with what plans Bell had to offer and wasn’t sure if the Pre developer ecosystem (and thus the applications available) would turn out to be as varied as the iPhone. So, I decided to join the cult.

Another reason that led me down this path was the fact that I already had an iPod Touch from earlier in the year, and so I was already used to the iPhone interface. (I’ve since sold the Touch) And yes, I do realize in that very article I berated the monthly cost of the iPhone only to now end up doing a complete 180 on the situation. It’s not that I’m happy with what I’m paying, but rather that I’m willing to suck it up. Such is the power of the cult, and perhaps one of the reasons for the iPod Touch’s existence – to suck users into getting an iPhone. After all, Steve Jobs did describe it as “training wheels for the iPhone”, but perhaps “gateway drug to the iPhone” would be more accurate.

Fido actually had some okay plans; okay for Canada that is. In the end, I’m paying just about $80 CAD a month. (including taxes) It’s about $50 more than I was paying for my old phone, which is quite a bit, but the iPhone has been invaluable in the intervening period after moving where I didn’t have Internet access at home. We’ll see if it doesn’t lose its appeal in the coming months.

In the meantime, however, it’s been a blast. There are literally too many apps out there to try, so I’ve only had a chance to play with the more popular ones. Some of my favourites include the AllRecipies dinner spinner, Wikipanion, Restaurantica (which I’m surprised isn’t promoted more on their website), and of course, Shazam, the accuracy of which continues to amaze me!

But the most useful features for me have been the always-available easy-to-use Internet access and the access to Google Maps overlaid with GPS. It’s been invaluable, especially after moving to a new city. Without it, I’d literally have been lost more than once.

Despite all the positive features, there are still some sore points. Firstly, battery life on the 3GS is atrocious, as reports have indicated. On a full charge, I can barely last two days with moderate data usage, some music playback and hardly any YouTube/video usage. Be prepared for the daily recharge should you get this phone.

Additionally, being an Apple product the iPhone looks very attractive but is a dirt/dust/fingerprint magnet. Even with the new oleophobic coating (fancy word for anti-fingerprint) you’ll still probably want to get a screen protector and case for this device. I’ve opted for the Speck PixelSkin, which I believe is one of the better cases out there, as it’s tough, rigid and adds a nice grip to the iPhone.

Lastly, there are no good default ringtones supplied with the iPhone! I don’t need some fancy pop-music ringtone, I just want something that sounds normal. Thankfully, a coworker directed me to the perfect iPhone ringtone, and I’ve since been happy with it.

I’ll leave you with some comparison pictures of the iPhone 3GS and the iPod Touch 2nd generation.

With JavaScript there are actually two concepts at play when using logical operators: What is actually returned from the result of a logical operation, and how variables are converted to boolean values when the context requires it.

Undergoing a conversion

Firstly, we’ll look at how variables in JavaScript are converted to boolean values. One way to explicitly convert a non-boolean value to a boolean one in JavaScript is to use the global Boolean object as a function. By using the following code, you can explicitly get the boolean conversion of a variable or expression:

var asBoolean = Boolean(someVariable);

The variable asBoolean is now guaranteed to have a boolean value. Note that this is not the same as the expression new Boolean(someVariable), as that returns a Boolean (wrapper) object representing the converted value of someVariable, not a boolean primitive.

So what values of someVariable will result in true being returned, and which ones will result in false? The following values will evaluate to false, while all others will evaluate to true:

• 0 or -0 (Most floating-point implementations have positive and negative zero, due to the IEEE 754 standard)
• null
• undefined
• NaN
• The empty string (“”)
• false itself

This means that all other expressions or values, including any non-null object (including the Boolean object for false!) and the string “false” will be converted to true.

Note that using the Boolean function isn’t the only way to explicitly convert a variable to its boolean equivalent. You could also apply the logical NOT operator twice, like so:

var asBoolean = !(!someVariable);

This is because the contract of the logical NOT operator in JavaScript is to return false if the operand can be converted to true and true otherwise. The second NOT simply reverses the negation done by the first NOT operator. While all of this may seem dead simple, it will be important to note as we move on to how other logical operators work.

Logical conversion

This is perhaps the most important difference with JavaScript. Although the logical NOT operator (!) is guaranteed to return a boolean value, the logical AND (&&) and logical OR (||) operators are not. This is by design, and although it might be a bit of a change for some developers, the feature can actually be quite useful.

Consider the following code examples:

var result = a && b

In this example of using logical AND, a is returned if it can be converted to false; otherwise b is returned.

var result = a || b

In this example of using logical OR, a is returned if it can be converted to true; otherwise b is returned.

This means that one of the original operands or expressions used with the logical operators will be returned as a result of the evaluation. You will not always get an actual boolean value, unless both of the operands were booleans to begin with. Usually, this doesn’t matter, since if you use the result in a boolean context, it will get converted to the expected value. For example:

var string1 = "";
var string2 = "a string that is not empty";
var result = string1 || string2;
if (result)
{
  window.alert("At least one string was not empty");
  window.alert(result);
}

This example will output “At least one string was empty”, and then “a string that is not empty”. This is because the logical OR operator first converts string1 to a boolean, which results in false. Thus, the result of the logical OR returns string2 into the result. Since the result is now a non-empty string, it converts to true for the if-conditional.

This also highlights a convenient way of using logical OR – give me the first expression if it evaluates to true, otherwise give me the second. This is usually used to test for the availability of built-in objects in a particular JavaScript environment.

However, consider the following example:

var string1 = "";
var string2 = "a string that is not empty";
var result = string1 || string2;
if (true == result)
{
  // We will never get here.
  window.alert("At least one string was not empty");
  window.alert(result);
}

In this slightly changed example, instead of directly supplying the result to the if-conditional, we test whether it is equal to true. In this case, it fails, since when using the equality operator, operands are not converted to booleans. (Using the strict equality operator also would not work)

This underscores an important point: If you actually want a boolean value to work with, you will have to explicitly convert it, using either the Boolean function or a double application of the logical NOT operator, like so:

result = Boolean(result);
// Or, we could do this:
result = !(!result);

Conclusion

JavaScript offers some neat features due to its dynamic typing and these can help speed development, but you just need to be aware of how they work so that you don’t get tripped up. This is especially true when dealing with implicit type conversion and how logical operators work. I hope you found this helpful and as always, any feedback is appreciated!

References

1. Logical Operators
2. Boolean Object
3. Boolean Description
4. Comparison Operators

To me, a lot of this UI complexity stems directly from a lack of separation between the UI and business logic layers.

Proper separation

As developers, we’re accustomed to the best practices of modularity and separating the implementation from the interface. This has lead to such patterns as MVC and Interface Oriented Design. However, when it comes to designing the UI layer, these rules sometimes aren’t followed. This is why we end up with overly complex “Search” pages, offering every option under the Sun, and configuration dialogs/screens with a one-to-one relationship to settings files or some other underlying implementation detail under the guise of “letting the user decide what they want”.

Without clear UI planning, this one-to-one relationship tends to rear its ugly head more often. Take our first example of a “Search” page. In most applications, the search functionality is interacting with some sort of a database backend, most likely a SQL RDBMS. The lazy approach is to design the search form based on the format of the SQL query itself. This is how we get search forms with multiple fields, drop-down boxes and so forth – because this format translates almost directly into a SQL query; i.e. of the form WHERE col1 LIKE... AND col2 LIKE...

Just because this is easier for the developer, doesn’t mean it’s the best solution for the end user. In fact, it’s often the case that this is the exact opposite.

Thinking like a user

In general, users don’t care about the implementation of your application or how it stores data. They shouldn’t have to know about the columns of the table where the data is stored, so why make a search form that exposes this? Instead, you need to understand what your users want and how they’re most likely to use your application. This isn’t an easy task, as many have pointed out.

This is where I think most UI problems come from – a misunderstanding of what users want. This isn’t to say that these developers are dumb or careless; but just that when it comes to empathizing with their users, they often are unable to because they know their own software and have such an intimate view of it from a coder’s perspective.

Take the example of QTTabBar, a Windows Explorer extension written in .NET that adds many useful features such as tabs, etc. to the interface. It is an excellent extension and does things very well, but the options page is a complete nightmare.

There are just too many options on this one page; what do they all mean? Furthermore, there are nine more tabs, each with roughly the same number of additional options! This is far too complicated, and I’m guessing most people will never have a use for all of these options.

Of course, it’s completely unfair of me to pick on QTTabBar in this manner, considering it’s written by one guy who has chosen to give it away for free. And, as I mentioned before, it’s a very useful utility that I can wholeheartedly recommend.

A simple story

Take a simply example, where we want to search a set of items, each of which have four separate properties – name, description, URL and tags. The items are displayed on screen with all of the four properties shown. The naive way would be to provide a search form that had fields for each property and allow users to search that way.

But with this simple (albeit contrived) example, there is an obviously simpler solution. Since all of the four pieces of information about an item are shown onscreen, it would be much better just to provide a single search field whose input would be used to search all four properties, returning all items that had a match in any of the properties. From a user’s point of view, this makes sense, since they are searching through what they know they can see and interact with.

If an advanced search was needed, it could be added later, but I would only do this if I knew it was absolutely needed by users, since the simple case is likely good for >90% of your users.

Motivation and Usage

There are numerous reasons for using the user’s location to improve the quality of a service. For example, the restaurant guide and review site, Restaurantica, automatically makes a guess as to your location and populates the “Search” field so that you are one click away from finding information tailored to your geographic area.

This determination is based on the user’s IP address. Usually, the lookup is done based on a static set of mappings from IP addresses to geographical locations, like cities. In fact, this is exactly what the IP address geolocation database (that we’ll use) does. It has the advantage of being easy to understand but unfortunately the accuracy can degrade over time, as IP addresses are usually not hardwired to specific locations. For example, most DSL users are subject to DHCP, so the same IP address may be re-used across different cities. (The IP address database from IPInfoDB is updated periodically to help reduce this inaccuracy)

Thus, you should not rely on the information provided to be 100% accurate; it should only be used as a suggestion. This is why Restaurantica only populates the search field with your estimated location, rather than giving you the results for that location right away; if it was wrong, the results for a different location would certainly be confusing to a user. This gives the user a chance to correct any inaccurate lookups.

Using the IP Address geolocation database

The first step is to download the database and import it into your local database; for this example I’ll use MySQL. Note that the site also offers an IP location Lookup API, which has the advantage of not requiring a local database but may be subject to usage limits; if you’ll be getting a lot of traffic you’ll be better off using the local database.

Import the contents into MySQL

I downloaded the Complete (City) database as one table in SQL format. Extracting the file from the archive, you’ll see that it’s well over 300 MB in size. If you’re fond of using phpMyAdmin, you unfortunately won’t be able to import such a large file using that tool, so we’ll have to rely on the command line to import the contents. Go to your mysql/bin folder and enter the following command, assuming you extracted the SQL file to the same location:

mysql -u root -p [name of database] < ipinfodb_one_table_full.sql

Running this command will take some time, as it won’t be fast having to import such a huge table. Take a break and come back in a few minutes. (You may want to create a new database to hold just this table, do that before running this command) After that’s done, you should be able to see the contents in phpMyAdmin, like below:

Using the database

Querying the database is straightforward, and the IP Info DB website has plenty of examples at the bottom of the download page. Basically, once you have the user’s IP, you can use a query like this to find the most likely city it originated from:

SELECT *
FROM `ip_group_city`
WHERE `ip_start` <= INET_ATON([ip address as a string])
ORDER BY ip_start DESC
LIMIT 1;

The INET_ATON function converts a string that is the dotted-quad octet form of an IP address (the form you’re most used to seeing) into a 32-bit unsigned integer. This integer is then used to locate the record that most likely corresponds to the geographical location. The database is structured such that row with the highest ip_start value not greater than the given IP address is deemed to be the most likely location.

An example:

SELECT * FROM `ip_group_city` WHERE `ip_start` <= INET_ATON('69.156.150.155') ORDER BY ip_start DESC limit 1;

(This returns the city of Toronto, Ontario, Canada) If you want to get a list of likely locations, just increase the LIMIT argument to something like 10, and this will return 10 locations that are likely close to where the IP address is located. Note that there may be duplicates in this list.

A simple example

Here’s a simple PHP script that takes the user’s IP address and displays their most likely location on a map using the Google Static Maps API.

<?php
$ipGeolocationDatabaseName = 'ip_geolocation';

$link = mysql_connect('localhost', 'root', '');
$ipAddress = mysql_real_escape_string($_SERVER['REMOTE_ADDR']);

echo $ipAddress;

mysql_select_db($ipGeolocationDatabaseName, $link);

$query = "SELECT * FROM `ip_group_city` " .
         "WHERE `ip_start` <= INET_ATON( '$ipAddress' ) " .
         "ORDER BY ip_start DESC " .
         "LIMIT 1";
$resultLocation = mysql_query($query);

$numRows = mysql_num_rows($resultLocation);

if (0 == $numRows)
{
  echo "No likely locations found.";
}

while ($row = mysql_fetch_array($resultLocation))
{
  echo "<pre>";
  print_r($row);
  echo "</pre>";

  $lat = urlencode($row['latitude']);
  $lng = urlencode($row['longitude']);
  if (!empty($lat) && !empty($lng))
  {
    // NOTE: Replace the `key` parameter with your own, obtained from:
    // http://code.google.com/apis/maps/signup.html
    // (The one in use is only good for URLs on `localhost`)
    $queryString = "center=$lat,$lng";
    $queryString .= "&zoom=10";
    $queryString .= "&size=300x300";
    $queryString .= "&markers=$lat,$lng,blue";
    $queryString .= "&key=ABQIAAAAicCf6MqoHlR-MsfivtVWPRT2yXp_ZAY8_ufC3CFXhHIE1NvwkxTNmqRdvnM9orG9QdyALHoUZfmFuQ";
    $queryString .= "&sensor=false";

    echo '<img src="http://maps.google.com/staticmap?' . htmlentities($queryString) . '" alt="location" />';
  }
}
?>

Here’s what it display for my IP address:

As you can see, it’s not always accurate, but it’s a good start to enhancing your website to offer localized services and features.

However, if you recently tried to upgrade to the latest version using the instructions at the WordPress Codex, you likely ran into a problem with an error mesage like this:

$ svn sw http://core.svn.wordpress.org/tags/2.8/ .
svn: 'http://core.svn.wordpress.org/tags/2.8/'
is not the same repository as
'http://svn.automattic.com'

This is because sometime between the release of 2.7.1 and 2.8, the URL of the WordPress SVN repository changed from http://svn.automattic.com/wordpress/ to http://core.svn.wordpress.org/.

The fix

To properly update WordPress after this change in the SVN repository location, we need to first run the svn sw –relocate command to relocate or point the checkout to the new repository URL:

svn sw --relocate http://svn.automattic.com/wordpress/tags/2.7.1/ http://core.svn.wordpress.org/tags/2.7.1/ .

Note that we are just changing the checkout’s repository from the old one to the new one – we aren’t yet pointing to the new version. (Note – this assumes you are currently running version 2.7.1)

After this, we can now we can switch to the new version.

svn sw http://core.svn.wordpress.org/tags/2.8/ .

Additionally, it’s worthwhile to run an svn up after this, just to make sure externals (like Akismet) are properly updated as well.

Note that this overall process has two steps – first pointing the checkout to the new repository URL, without switching to the new version, and then switching to the new version. I am not sure if you have to do it in two steps like this, but I can confirm this worked for me, and judging by the instructions in the SVN documentation, this is likely the correct way.

As reported a little while ago, Sun plans to launch their own app store for Java-based desktop applications. With Apple’s App Store having passed the one-billion download mark last month and thus proving to be a roaring success, it’s clear that Sun, like many others, is hoping to imitate and perhaps improve on the effort. But does it make sense?

Mobile vs. Desktop

Following in the steps of RIM, Google’s Android, Palm and others, Sun hopes to follow the same pattern of success that Apple has enjoyed with their App Store. However, things are a bit different here. All the current App Store competitors have a separate mobile platform with which to compete against Apple. In general, this business model makes sense because there are few other easy ways to get software onto the devices, so a centralized app store of sorts makes sense.

In Apple’s case, they intended from the beginning to have the App Store be the only way to get software onto their devices. This closed-model and high level of control, which Apple is known for, is what helped make the App Store so popular. It was also very easy to use, and provided functionality not available elsewhere. Other mobile app stores aim to emulate this “app store tie-in”, hoping to make their respective app stores the primary place to get new software for your device, thus providing the companies with a steady source of revenue.

On the desktop, thing’s aren’t so clear. For the most part, people are already able to freely and easily download/purchase and install software, either through their web browser or through content delivery systems like Steam. Sun will have some real competition on their hands because of this, and unless they can create the ecosystem to spawn “killer apps”, people won’t be flocking to it in droves. Currently, there are just too many options for getting new software onto your desktop, thanks to the openness of the system, and this will be a real problem for Sun when it comes to gaining any significant market share in this area.

Furthermore, as noted in the article, there haven’t been very many compelling Java apps, save for Eclipse and Azureus. (I only use the former) Java on the desktop just hasn’t been as much of a success as Sun would’ve hoped for, mainly because Java desktop applications haven’t had the same consistent look & feel that native OS applications have offered, with some notable exceptions like Eclipse. While Java has gained much acceptance on the server side, it may have to settle for this before looking to gain significant acceptance on the desktop anytime soon.

App Store Hype?

It should be also noted that while the Apple’s App Store has been a roaring success for the company itself, it seems that it’s not as much of a success for the vast majority of developers out there. Like most markets with low-barriers to entry, (blogging for profit, startups, etc.) the distribution of revenue seems to follow a long-tail model, with very few developers making a lot of money, with the rest only making a fraction of that.

This was highlighted by a recent TechCrunch article about the reality of the App Store, which referenced an original article by an App Store developer. In that article, the developer revealed that because there were so many apps available for download, it didn’t take much to get into the top 100 for a given category:

In order to place #34 on the social networking charts, you need 30-35 downloads a day. At the standard app store pricing of .99, and after Apple takes its cut, that means your app needs to bring in a little over $20 a day to chart at that position. And social networking is a popular category.

Thus, it would appear that App Store not as profitable for developers as the hype or large success stories would suggest. You may have a compelling app that is nicely done, but it may only make a marginal amount instead of the six-figure amounts being seen by some of the most successful apps. If this is the case with even a successful implementation like Apple’s App Store, how does this bode for Sun, which hasn’t even proven that their Java app store can enjoy similar success? Indeed, it appears that they will have a hard time attracting developers to their app store platform.

Mind you, this hasn’t stopped people from even speculating about an Ubuntu app store, though it’s hard to see this business model working well with the FOSS model of Ubuntu. Nevertheless, it wouldn’t be unrealistic, given that Canonical is trying to make Android apps run on Ubuntu, possibly allow for Android’s app store to make an entrance to the desktop through this backdoor method.

If you’re using Maven to manage your project’s build and dependencies, you may have encountered some problems when trying to include the latest version of log4j as a dependency. Specifically, log4j 1.2.15 depends on some artifacts that are not available in the central Maven repository due to licensing issues, and thus when you try to build a project that depends on this version of log4j, you may not be able to download the artifacts and your build will fail.

We could download and install these artifacts to the local repository, if we really needed them. But in most cases, they’re not needed and thus you won’t want your project relying on these artifacts just because some parts of log4j do. Thus, we need to exclude them.

The problem: Not really needed

The issue is going from log4j 1.2.14 to 1.2.15, the developers added some features which required some dependencies on various sun and javax packages. However in most cases, you won’t be using this extra functionality, but if you just include log4j 1.2.15, this will cause your project to require those extra artifacts as per the transitive dependency rule.

Because some of these artifacts are not available from the central Maven repository, due to licensing issues, they will not be automatically installed to your local repository. So, if you attempt to run mvn install, you’re likely to encounter this sort of error:

[INFO] Unable to find resource 'com.sun.jdmk:jmxtools:jar:1.2.1' in repository central (http://repo1.maven.org/maven2)
[INFO] Unable to find resource 'javax.jms:jms:jar:1.1' in repository central (http://repo1.maven.org/maven2)
[INFO] Unable to find resource 'com.sun.jmx:jmxri:jar:1.2.1' in repository central (http://repo1.maven.org/maven2)
[INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Failed to resolve artifact.

Missing:
----------
1) com.sun.jdmk:jmxtools:jar:1.2.1
...
2) javax.jms:jms:jar:1.1
...
3) com.sun.jmx:jmxri:jar:1.2.1
...
----------
3 required artifacts are missing.

And if you’re using Eclipse, and have used the Maven Eclipse plugin command (mvn eclipse:eclipse) to generate the project settings, you’ll have the problem of Eclipse not being able to find the artifacts references on the build path, resulting in an error like so:

This causes a big problem as it essentially prevents you from building your project. You could download and install these artifacts to your local repository, but since they’re not really needed, we should exclude them from the dependency list for log4j.

Excluding dependencies

Thankfully, Maven make it easy to exclude dependencies from a certain project. Looking at the log4j 1.2.15 POM file (you may have to select “View Source”), we can see several dependencies that weren’t there in the previous release. These are likely to support new features, and aren’t needed for the most common uses of log4j. Here are the actual dependencies for log4j 1.2.15:

<dependencies>
  <dependency>
    <groupId>javax.mail</groupId>
    <artifactId>mail</artifactId>
    <version>1.4</version>
  </dependency>
  <dependency>
    <groupId>javax.jms</groupId>
    <artifactId>jms</artifactId>
    <version>1.1</version>
  </dependency>
 <dependency>
    <groupId>com.sun.jdmk</groupId>
    <artifactId>jmxtools</artifactId>
    <version>1.2.1</version>
  </dependency>
 <dependency>
    <groupId>com.sun.jmx</groupId>
    <artifactId>jmxri</artifactId>
    <version>1.2.1</version>
  </dependency>
 <dependency>
    <groupId>oro</groupId>
    <artifactId>oro</artifactId>
    <version>2.0.8</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
  </dependency>
</dependencies>

We only need to exclude the first four, and not the last two, since they have a scope of test, and won’t be included anyways. To exclude these dependencies, add the log4j 1.2.15 dependency as show below.

<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.15</version>
  <scope>provided</scope>
  <exclusions>
    <exclusion>
      <groupId>javax.mail</groupId>
      <artifactId>mail</artifactId>
    </exclusion>
    <exclusion>
      <groupId>javax.jms</groupId>
      <artifactId>jms</artifactId>
    </exclusion>
    <exclusion>
      <groupId>com.sun.jdmk</groupId>
      <artifactId>jmxtools</artifactId>
    </exclusion>
    <exclusion>
      <groupId>com.sun.jmx</groupId>
      <artifactId>jmxri</artifactId>
    </exclusion>
  </exclusions>
</dependency>

This tells Maven not to add those artifacts to the classpath and so they won’t be needed to build your project anymore. Note that you have to explicitly exclude each one, there is no way to exclude all of the dependencies for a project, but there is a feature request for such an ability.

If you’re using Eclipse, after running mvn eclipse:clean/mvn eclipse:eclipse, you should have the build path properly setup without any missing artifacts:

Everything should now work!

Transitive Dependencies and Exclusions

The issue here is that the log4j 1.2.15 POM file probably should have marked these dependencies as optional, which would have had the same effect as having to exclude them on every project that referenced that version of log4j. What does an optional dependency mean? The Maven website has a pretty good explanation.

Basically, if you have a large project that requires a lot of dependencies, but the “core” features only require a subset of those dependencies, you may want to mark the others as “optional” so as not to burden any projects that reference yours. Your project will still need all of the dependencies to build, but other projects that reference yours will only need the optional dependencies if they are using the additional features. In this case, they’ll have to explicitly add those dependencies, as the transitive dependency rule won’t kick in for “optional” ones.

Also worthy to note: exclusions are done on a per-dependency basis. This means that the dependencies that we excluded from log4j are only excluded from the log4j scope. This has the effect of not globally excluding those dependencies. So, for example, if we added another dependency that did really require the javax.jms/jms artifact, it would not be prevented from being added. Furthermore, if we wanted, we could manually add a dependency to our own list for that JMS artifact, and it would show up as normal.

References

1. Exclude Transitive Dependencies
2. Maven and Excluding Transitive Dependencies