Microformats: Empowering Your Markup for Web 2.0

product

Haven’t heard much about Microformats? They are relatively new to the web, but use existing practices just marked up in a uniform way to add new meaning. They’ve been getting a lot of attention lately with adoption at Yahoo, Technorati, LinkedIn, Upcoming, Flickr, Last.fm, Eventful and much more. By marking up their pages in this way, they become more easily parseable by others’ application. For example, Technorati recently created a Microformats search which is still gaining traction. It does work though, as as a serch for ColdFusion reviews shows.

The entire purpose of microformats is that they use existing technology (css, html, xhtml) to create semantic, machine parseable information. What’s that mean? It means creating something that’s straightforward to a developer, but follows a strict enough standard that it can be intepreted in a predictable manner as well. To make things a little more clear, how about we start off with an example, XHTML Friends Network. If you take a look at the code for the blogroll on my front page, you’ll see a sample link looks like this:

<a href="http://www.brianlegros.com/blog/" rel="friend met co-worker">Brian LeGros</a>

The relation between me and Brian LeGros is that of “friend met co-worker”, which is straightforward enough in it’s meaning. There is actually a special set of relationships that are available in this context, although they are very broad. They cover relationships such as friend/acquaintance, co-resident/neighbor, child/parent/sibling, muse/crush/date and me, to reference another site about you (would usually be used for myspace/facebook links for example). Since the XHTML standard has nothing against using multiple, space separated relationships, this is a very clean and easy way to markup a set of links, and one that Wordpress helps out with.

Reading through Microformats there were more than a few times when I put the book down and decided to implement them then and there. That’s one of the most exciting things about this book — it’s a call to action, and an action anyone who has a web presence can make.

It starts out with very simple microformats such as XFN (short for XHTML Friends Network), and other link-based microformats. Two of these were immediately useful to me — rel=”nofollow” and the VoteLinks Microformat.

You’ve probably heard about the rel-nofollow microformat without even knowing it was one. The idea is that you add

rel="nofollow"

to any link and that link will not be traveled by search engines. Also, that link will not gain pagerank from the link (and your sites pagerank will not be used up on the link). rel-nofollow was introduced by Google and has become the standard for all links that are made within blog comments.

Another one along the same lines is Votelinks which has a few more options. The idea is that you can markup a link which serves as a vote for, a vote against or a null vote for the related link using the “rev” attribute of a link. The possibilities are:

rev="vote-for"
rev="vote-against"
rev="vote-abstain"

Now when you see one of those sensationalist articles about ColdFusion dying, you can just mark it up accordingly.

<a href="http://www.softwaredeveloper.com/features/ghosts-in-machine-071207" rel="nofollow" rev="vote-against">Ghosts in the Machine: 12 Coding Languages That Never Took Off</a>

Microformats goes into these formats at much more detail, as well as providing some examples on styling them (a[rev="vote-against"]) for one. By starting with these extremely easy to implement microformats, this book gets your ideas rolling.

Some of the more complex microformats, such as hCard are built line by line from the simpliest parts up until you have a full hcard. This approach is used throughout the book and works well. hCard is also one of the best examples in the book, with a full walkthrough of how an hCard might be marked up.

You might be thinking microformats are just a matter of adding a little markup and that’s it, but it’s actually quite a bit more complicated than that. For the most part, microformats are marked up by adding classes with specific names to any element. For instance, take hCalendar; a microformat used to markup events. It’s obvious an event needs a title, a date, maybe location, description — and that’s just for starters. What if the event spans multiple days? Who’s the coordinator? Where is the event located? Well when you get into questions like this you start nesting multiple microformats to make full hCalendar. There is hCard microformat to communicate the coordinator (or any person), a whole location markup with geo coordinates, and a way of providing the start date and end date. These little pieces can be reused in other microformats as well.

That’s really what this book helps with — getting a grasp on the building blocks. I don’t see myself wanting to memorize the individual pieces of most microformats, but after reading this you should have an idea of when they can be used with a handy reference for finding out more. As far as Microformats books go, it’s the best one out there — it’s also the only one listed or planned for release.

One thing I would’ve liked to see is a little more styling of some of the microformats. Microformats does style a few of the examples but not all. At the end there are two “case study” chapters going into detail on how Cork’d and Yahoo have used microformats. These provide full styling examples as well. Cork’d was co-created by Dan Cederholm, author of Bulletproof Web Design, and reading his writings has been one of the best ways of helping me learn best practices.

I’d suggest microformats as a subject anyone in web development could easily get the hang of in almost no time at all. If you use ColdFusion, you can always try the Microformats project on Riaforge to help get started. This book is a great resource though, and I’d highly recommend it to anyone interested in learning more.

My rating: 4.5 stars

Adobe Flex 2: Training from the Source

product

Book Review for one of the few Flex books available

If you’re looking to learn Flex, you more than likely will come across this book at some point in time. With Flex 2 not even a year old, only a few books have had a chance to come out on the topic. Of the ones that are available this is the only official training from the source. I decided it would be the best place to jump into the Flex world.

The Format
At 624 pages and 25 task driven chapters, it’s not a quick read. Actually it’s not one you can sit down and read at all. The entire book is done in instructional format, where you’re usually given a numbered list of tasks and changes you need to complete. Usually this will be in the 10-25 item range, at the end of which time you’re able to build the project and see how your changes are going (and in doing so make sure you’re still on track with the book). At the beginning of each chapter the contents, estimated time to compete and filelists are listed. These time listings should be taken seriously. If it says 30 minutes, assume 30 minutes, if it says 2:30, assume 2:30. With most chapters around 2 hours, plowing through the entire book will take longer than one work week. I found myself getting tired out by all the repetitive typing and quirky problems that more breaks were required.

The Content
Taking on Flex 2 and Actionscript 3 is no small task. I didn’t realize how much there was to it to be honest. This book does a good job of laying out the basic building blocks by having you build a sample “Flex Grocer” application. This is a front end for a store where the user can browse various categories, add products to their cart, view/edit/remove items in their cart and eventually check out. It is also equipped with an administration application for managing the grocery items. The product data for this application is provided in XML files, and later on in the application can be controlled using ColdFusion and a provided access database. The attached CD comes with an already configured ColdFusion 7 installation with Flex Data Services and the required datasource setup. This saves time getting everything setup. I would recommend using it even if you have ColdFusion installed already. The appendix at the back of the book has the details on how to install this, as well as the readme files on the CD.

Some of the most useful content comes in when it explains sample application structures. Maintaining applications usually takes up considerably more time than the initial development, so having well organized code is extremely important. This is just an example though, and doesn’t go into Cairngorm, the popular Flex framework. I don’t know if Caringorm is the right choice, but it would be nice to have at least a mention of it and a comparison to the methodology described. Often a “quick and dirty” way of solving a problem is described, mentioning that it’s not the suggested way of doing something. Later on the “right way” is described. This approach was helpful and described what you should not do just as well as what you should.

What I Didn’t Like
The most frustrating moment in each chapter was without fail the moment I would go to compile the last set of changes only to find my project not compile. This usually just meant going back through and double checking my typing (or copying line from line from the book I should say). On one occasion though, I had everything correct; I even copied the “finished” files from the CD only to still see the same error. I believe it was remove from cart button. This really annoyed me for a while, and it’s not mentioned on the official page for the book. This isn’t a “Hands on Training” book, but it is only effective by active participation rather than reading. I was hoping it would use more of a combination of both similar to Head First Design Patterns, but it turned out to be all repetitive typing. The lack of space between typing meant that everything learned in the book was learned from action. I’d be up for reading another book on Flex just to get a better idea of the syntax. This was a good intro into a lot of aspects of Flex though, which could not have been done as easily in alternative methods.

How Was it?
Of the Flex books on the market, this is probably the place where you want to start. It’ll give you a decent intro into many aspects of Flex if you have the patience to sit down and make it through the often mundane examples. For the time being it’s probably the best book on the market, and should give enough understanding to start (slowly) starting actual Flex development. If you want to add a framework to the mix you’ll still need to learn that on your own, but you should be able to understand the concepts at the very least.

My rating: 3.0 stars