The web community has been up in arms the last day or so about a campaign via Twitter pushing for Outlook 2010 to stop using the Word rendering engine for HTML email. I engaged in a short friendly discussion with my buddy Vlad on Twitter about the issue, and that got me thinking about the issue a bit more deeply. And the more I thought about it, and read everything that was being written, the more I realized that people aren’t actually communicating effectively, and that pisses me off…

The fixoutlook.org website says this: “Microsoft has confirmed they plan on using the Word rendering engine to display HTML emails in Outlook 2010.” (emphasis added) Based on that, and the rest of the text on the site, it seems like the big beef they have is that Word’s rendering engine for HTML is not up to snuff. Fair point – it isn’t. But they contradict themselves in their updated response to Microsoft’s response when they say, “We’re asking that the HTML produced by the Word engine be standards compliant. This in turn will ensure that the engine will correctly render standards-based emails.” (emphasis added)

Wait a second. Do they want an editor that produces HTML, or a rendering engine that works properly? Doing the work to make sure the editor is producing clean markup might produce a rendering engine that renders nicely, perhaps it even should produce one, but that doesn’t mean it will. Those two pieces of work are not the same thing.

Lots of people have been pointing to a post from Zeldman about this. Zeldman’s a brilliant guy, but he completely misses the point when he perpetuates a rumor about why Outlook chose Word’s engine: “Rumor has it that Microsoft chose the Word rendering engine because its Outlook division “couldn’t afford” to pay its browser division for IE8. And by “couldn’t afford” I don’t mean Microsoft has no money; I mean someone at this fabulously wealthy corporation must have neglected to budget for an internal cost.”

Ummmm… no. In my experience, the phrase “couldn’t afford” at Microsoft R&D has nothing to do with monetary cost. It has to do with engineering cost. Features don’t exist just because you want them to exist. (An aside: Raymond Chen has a great quote about this that I can’t find. If you have a link, please let me know.) So I imagine that the rationale in the Outlook team went something more like this:

Well, we want Outlook to produce really rich emails, and we want it to have a really familiar look and feel, so people already using our products will feel at home. Hmmm, building an editor is extremely hard to get right, plus we, being part of the Office suite, have several editing tools already. Emails tend to be a lot like documents, so Word seems to be a reasonable choice. This way we can leverage all the editor features Word already has, plus things they’re building this release, and focus on the Outlook-specific work we have to do. We don’t want to invest our engineering time in building an editor when we already have one.

From this standpoint, it’s easy to see why using Word for rendering as well is the next logical step. You could argue that they should use IE (or Gecko, or Webkit, as Zeldman does, but again, just because those engines are free doesn’t mean using them is without cost) to render email, and Word to author it. That’s a reasonable idea. In fact, the Outlook team seems to agree with you, because if you get an HTML email that looks wrong, you see a link to open it in a browser. In fact, even the example image at fixoutlook.org has the “info bar” at the top that does this.

You can take issue with the implementation, certainly, because it sucks mightily. The fact that I have to open the email in a browser separately blows. I shouldn’t have to do that. But don’t kid yourself into thinking that integrating an IE window into the message window is so stupidly simple that Microsoft is maliciously avoiding doing it to somehow screw users. It might be straightforward – I honestly don’t know. But do you? If you think you do, please go read Steve Yegge’s post “Have you ever legalized marijuana?” and come back.

What really bugs me about this whole thing is that people immediately jumped on the fact that Outlook uses Word for rendering, instead of sticking to the real problem that Outlook’s rendering of HTML sucks in some cases. The rendering engine they’re using is immaterial, really, because if the team goes and fixes the rendering inadequacies, then the issue goes away. They can choose how to fix the issues, should they choose to fix them at all, but at this point, even if all the rendering issues are fixed, many people will still be pissed because Word is used to render the email. The argument has shifted from being about the support proper email display to being about Word used for rendering, so there doesn’t seem to be a path to redemption for Microsoft in the court of public opinion that doesn’t involve ripping out Word completely.

I completely agree, personally, that web standards serve as a reasonable basis for email format standards even though there is no formal effort to standardize email. But please argue about the right things. Spend your energy trying to see those standards acknowledged rather than perpetuating this silly argument about ripping out Word from Outlook. Hopefully this effort will have the desired effect, and these rendering issues will get resolved prior to Outlook 2010 RTM. But I can almost completely guarantee that if you want Word completely ripped from Outlook, you’re not going to get what you want.

By the way, does anyone have a screenshot of what the email used in the example image looks like in Outlook 2007, which also used Word for rendering? That struck me as a strange omission. I’m wondering if the issues displayed in that screenshot are just bugs in the 2010 beta. I doubt it, but would still like to see it.

Also – is there any way to get a sample HTML email from the Email Standards Project’s email acid test? Seems ridiculous there’s no “email me this sample email” form on the acid test page. I can and will file a bug against Outlook if I can get a copy mailed to me.

This didn’t really fit into the overall flow of the post above, but I still think it’s reasonable info to consider, so I’m including it here anyway. I’m about to throw out a bunch of numbers and statistics that are not backed up by any data. They are based only on my own logic and occasionally rational mind. I think they’re true and reasonable statements, but I welcome data that contradicts them.

I think it’s safe to say that a majority, say, 80%, of Outlook users use it with Exchange. Also, a majority of Exchange users use Outlook, and Exchange is primarily used in business settings. Since a large majority of email sent in a business setting is sent to other people in your business, then they’re probably also using Exchange, and also probably using Outlook. Based on this not-so-scientific reasoning, I argue that the number of emails received in Outlook that didn’t originate in Outlook is relatively small. That means, practically speaking, that as long as Outlook can render email that started in Outlook, you’re hitting the majority of your users’ needs.

Now, the idealist in you (and me, for the record) is screaming bloody murder, because you want to see the “right thing” happen for all cases, not just the majority case. But unfortunately, software is more about practicality than idealism, and at some point some smart, but possibly naive people in Outlook made a tradeoff. I’d say with 99% certainty that at some point a developer or two in Outlook estimated the cost of different approaches and implementations, and this one wound up cheaper. They made a cut. They made a tradeoff. And we disagree with the tradeoff.

• I get double-exposure to their content. If I am interested enough in someone to follow them on Twitter, and they also have a blog, then 90% of the time I also subscribe to their RSS feed. That means I see their posts in Twitter then also in my feed. That bugs me.
• Tweets are limited to 140 characters, and typically blog posts are longer. That means I see 100 characters plus a link, possibly less in the tweet itself. That’s useless.

At the same time, I find myself tweeting a lot of links, because Twitter is just a more vibrant community than my blog. I get a lot more comments and replies from people there than on my blog. Twitter is a decent place to broadcast stuff, but I don’t like the fact that I can’t easily find the stuff I’ve posted later. Have you tried using Twitter search to find a link you yourself posted in the past? It’s ridiculously bad. I figure if I can just keep it on my own site at least I have more control over the search experience. Another reason I want to do this is to have a centralized place to write stuff, then choose how it’s syndicated. This will let me do that.

In order to address the two issues I have with common auto-tweet solutions, I’ll only be tweeting some of my posts. I am doing this by feeding only posts tagged “tweet” to Twitter via TwitterFeed. In addition, I grabbed a WordPress plug-in that does character counts of posts in the WordPress web UI. This will help me keep my posts that are auto-tweeted short and completely digestible as a complete tweet.

Hopefully this will all come together and work. Let me know what you think.

The key to doing this is loading the SharePoint DLLs into your PowerShell environment. You can do this using the System.Reflection.Assembly class. Take a look at this sample script:

param( $newTimeout = 600 ) [System.Reflection.Assembly]::Load("Microsoft.SharePoint.Publishing, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c") $cdconfig = [Microsoft.SharePoint.Publishing.Administration.ContentDeploymentConfiguration]::GetInstance() $cdconfig.RemoteTimeout = $newTimeout
$cdconfig.Update() "Updated RemoteTimeout to $newTimeout seconds."

In line 3, I load up the Microsoft.SharePoint.Publishing DLL, then I grab the ContentDeploymentConfiguration (line 5) using the GetInstance() static method. I update the RemoteTimeout property, then call Update(), and we’re done. No code to write and compile.

This example uses the param keyword, which means you can save it as ChangeRemoteTimeout.ps1, then run it like this:

PS C:\> ChangeRemoteTimeout –newTimeout 1200

This is completely optional, of course, but if you find yourself doing this a lot, it might be worth saving it as a reusable script.

You might also want to make changes to some of the options that are exposed through the UI already. Here’s an example:

PS C:\> [System.Reflection.Assembly]::Load("Microsoft.SharePoint.Publishing, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c")
PS C:\> $cdconfig = [Microsoft.SharePoint.Publishing.Administration.ContentDeploymentConfiguration]::GetInstance()
PS C:\> $cdconfig.AcceptIncomingJobs = $true
PS C:\> $cdconfig.RequiresSecureConnection = $false
PS C:\> $cdconfig.Update()

In this case, I’m configuring the farm to accept incoming deployment jobs and not require secure connections. You can also make additional changes to other properties, such as FileMaxSize and RemotePollingInterval using this method. Stefan covers these properties in his Pimp My Content Deployment Job post.

One other note… Using .NET DLLs in PowerShell is generally supported across the board. It’s not limited to the SharePoint DLLs. There’s some pretty exciting stuff you can do here once you start playing around.

I started calling these Wikipedia Walks. The concept is simple - start at an article you find interesting, then just continue on to any articles linked from the original. Finish when you get bored. To make it more interesting, you should record both the starting article and the ending article, so you can see just how far off the beaten path you’ve gotten.

To start, I’d suggest the article on Game Theory.

Office 2010: The Movie

Now, if you’ve used SharePoint for any length of time, you’ve no doubt been frustrated with permissions management. It’s definitely a sore point. Unfortunately, I don’t have any magic bullets or golden hammers. When I started trying to figure everything out so that I could make educated decisions for our designs, I realized that I needed to write stuff down. People always asked questions like, “What rights do Designers have by default?” Sure, you can find out by going to the site itself and checking, but the UI isn’t the easiest to navigate, and oftentimes what you really want to do is compare multiple permissions levels. “What rights do Designers have that Contributors don’t?”, for example. To help keep it all straight in my mind (and so I could point people to the info rather than answer 100 emails a day with the same question!), the SharePoint Permissions “Cheat Sheet” was born.

It’s nothing fancy, and it’s certainly not anything that no one else could have created. But still, it has proven useful over the past few years. I still keep a copy of it pinned to my office wall. It’s pretty self-explanatory. The first sheet has a table of the default publishing permission levels and what fine-grain permissions each of them has. The second sheet is just the descriptions of each of the fine-grain permissions so I didn’t have to go hunting through the UI to find them whenever I was wondering what the differences were. Finally, the third sheet is a list of “securable objects” (which what I decided to call a list/library that had broken away permissions inheritance and was independently secured) and what default groups had what rights to those locations by default. This was particularly important since in general, you want to avoid breaking permissions inheritance if you can, and we wanted to be very deliberate about where we did, and also track them to ensure they made sense over time.

So how exactly do you use this? Well, it can be a handy reference as-is, but chances are that you have your own permissions level or have modified the existing ones to suit your needs, so you can modify this sheet to reflect your own custom permissions and keep track of everything. It really is helpful to have a centralized reference of all of the various permissions levels. If you go through and put in your own levels, you might realize that there’s a lot of needless duplication in the custom permission level you might have created. When it comes to SharePoint permissions, less is better, so this can be a helpful auditing tool as well as a reference.

A couple of disclaimers… This was created based on the RTM version. As far as I know, nothing has been changed in SP1 or SP2 that would impact it, but I haven’t been checking to keep it up to date. If you do notice errors you can let me know and I’ll try to correct it. Also, this obviously won’t take into account any customizations that you may do that would alter the default permission levels.

If you use this for any of the purposes listed or for additional things, leave a comment! I’d love to hear how it’s working for you and if it’s been helpful. Download it below:

SharePoint Permissions “Cheat Sheet” (XLSX)

One school of thought I come across quite frequently is that web content whose markup is not well-formed or is missing required attributes or something just fail to render completely, in order to ensure that all content on the web is gorgeous, standards-compliant markup. This ridiculously draconian viewpoint loses sight of the fact that the ultimate goal of delivering content over the web is just that – delivering content. It seems bad form for a browser to just “give up” when markup is badly formed, because the end-goal of the person building the page – and the person consuming it – is to deliver content. Much of this debate has been chronicled by the IE team; they have a tough job – bring the standards compliance of IE into this century without breaking their customers/users pages. Hence compatibility mode, legacy rendering, etc. etc.

In the past, I’ve always heard this argument from the standards-compliance standpoint. For example, if a page claims to be XHTML but isn’t fully compliant, it should fail to render in a browser. No “best-effort” rendering, just fail. This of course ignores the fact that even the W3C can’t create a parser that can completely validate a page against the spec, but that’s a rant for another time… Assuming the browser can detect that a page is non-compliant, it should just stop.

Anyway, this is a long and winding intro to a post Mark Pilgrim wrote talking about this viewpoint as it applies to accessibility. I had never heard these arguments before, but apparently they’re out there. A choice quote from Mark’s rebuttal (emphasis mine):

I think it would be wise for people who truly care about accessibility to take a closer look at the so-called “experts” who are participating on their behalf, and to understand exactly what these people are proposing. It’s true that some of their proposals have not been adopted, but it’s not because some cartoonishly monocled villain enjoys being mean to them. It’s because the proposals are insane.

Agreed.

In my most recent weekend project, I need to randomly sort a list of cards, which are represented by an Action class. After some quick searching, I found some articles that indicated the best way to do this would be to sort the list by random GUID. This makes sense, though I certainly wouldn’t have thought of it on my own.

The examples given all worked, but not with my lists… With the following code, the compiler spits out several errors:

List<Action> cards = new List<Action>();
cards.Add( new OneCattle() );
cards.Sort( a => Guid.NewGuid() ).ToList<Action>(); Error 1 Delegate 'System.Comparison<agricola.Action>' does not take '1' arguments
Error 2 Cannot convert lambda expression to type 'System.Collections.Generic.IComparer<agricola.Action>' because it is not a delegate type
Error 3 Cannot implicitly convert type 'System.Guid' to 'int'
Error 4 Cannot convert lambda expression to delegate type 'System.Comparison<agricola.Action>' because some of the return types in the block are not implicitly convertible to the delegate return type 

However, using a more explicit LINQ query without a lambda expression seems to work fine:

var q = from a in cards orderby Guid.NewGuid() select a;
List<Action> r = q.ToList<Action>();

Anybody know why this is? I haven’t wrapped my head around lambda expressions and the theory behind LINQ to understand what the root cause is…

The main www address should be redirecting to blog.tylerbutler.com as soon as the DNS changes propogate. The main RSS feed should be switched over, but I have not yet moved the others. Regardless, though, you shouldn’t notice any differences since I’m using FeedBurner.

More details on this SharePoint blog post and KB article 953878.

While I was in college, I discovered a site that I have since lost many hours of my life to - folklore.org. It’s a site put together by Andy Hertzfeld (not to be confused with Don Hertzfeldt of Rejected fame), and contains "anecdotes about the development of Apple’s original Macintosh computer, and the people who created it." It is incredible - it combines my love of stories with a topic I find interesting - the early days of personal computing. Best of all, the stories there are written by the people who experienced it, and often contain a healthy dose of humor and humanity. But behind that, there’s some cool technical details about the challenges the engineers faced, and why some of the decisions got made the way they did. I find that part of it utterly spellbinding.

I’ve been on the lookout for other sites like this for other tech companies, like Atari or even Microsoft. The closest I’ve found for Atari is DadHacker.com, written by a guy who worked for Atari back in the day. His blog is interesting in a variety of ways, but I particularly like his Atari posts. In fact, his post titled Donkey Kong and Me was what got him into my RSS reader permanently. It’s good - you should read it.

I actually work with a developer who was also on the team that developed Clippy, and I’ve heard some interesting stories for him about what that was like. Maybe I’ll try to convince him to write up some of his experiences… :-) I am sure there are some more great stories out there… If you know of some sites, please do point me to them.

Because I find this stuff so interesting, I thought it would be good to start chronicling some of the stuff I know about because I’ve been working on SharePoint. Thus, I plan to write a series titled "But Why?" about various SharePoint features that I either worked on or have been exposed to, and why they behave the way they do. These posts will be one part SharePoint history, one part storytelling, and if I do it right, will pull back the curtain a bit so you can see just why things wound up the way they did.

But first, some disclaimers: These posts are my own thoughts and opinions, and do not reflect those of Microsoft or of anyone else who works/worked on SharePoint. Also, my memory may be fuzzy and blatantly incorrect about some things, so everything should be viewed through that lens. Finally, you shouldn’t expect these posts to be as interesting as anything you read on folklore.org. :-)

A quick plug for Gandi - they’re nearly twice the price of some other registrars, but I stick with them because they have a great interface for editing DNS records, they give you a lot of control over the DNS settings themselves, they can host mail for your domain, etc. Well worth the additional cost as far as I am concerned. Highly recommended.

At Microsoft’s MIX07 conference, Tyler Butler, a program manager for Microsoft Office SharePoint Server, pointed out three Web applications built on SharePoint — Hawaiian Airlines, mobile phone game firm Glu Mobile and music and event firm Hed Kandi Radio.

Butler also indicated that, since the SharePoint 2007 platform is built on ASP.NET 2.0, developers can use ASP.NET AJAX and Silverlight to provide a rich user interface.

I’ll try not to let the fame go to my head. :-)

Better Search

Vista’s Search is integrated throughout the OS, and it’s so much better than XP’s search companion that a comparison is insulting. This one’s a no-brainer to get on XP. If you don’t already have Windows Desktop Search or Google Desktop, download one of them immediately. I prefer WDS 3.0 myself, because it feels a little more integrated into the Windows environment, but they’ll both do the trick.

Explorer Breadcrumbs

While I still sometimes miss the "Go up" button when using Vista, the breadcrumb is a much more usable way to get around a folder hierarchy. Pick up Minimalist’s Explorer Breadcrumbs, and you’ll get something pretty darn close in XP.

Start Bar Search

In Vista, when you hit the Start button, you can type some text and it’ll automatically search your applications in the Start menu and match on what you type. So if you type "word" both Microsoft Word and WordPad will pop up. Once you select one, it remembers, so the next time you want to start Word, you can just press the Start button (either using the mouse or the Windows Key on the keyboard, which is faster), type "word" and press enter. Fast.

Power users have been doing something similar on XP and Server 2003 using the "Run…" menu for years. Win+R to bring up the menu, then type the cryptic name of the program you want to run, like winword (Word) or mstsc (remote desktop client). This works well, but it requires you to remember the exact executable names for each app. Open source app Launchy to the rescue! It makes its own index of your start menu, and once you invoke it using a hot key (I use Win+Space), it works pretty much just like Vista. It even indexes your Control Panel items, just like Vista. No more hunting for those hard-to-find items in the control panel!

Cursors

Vista includes some new cursors. Some people don’t like them, but I think they look pretty snazzy myself. They’re available for XP. You can Google for them, or there are some from an old Vista build at http://www.gurudesign.no/downloads/aero_cursors.zip.

Windows Media Player 11 and Internet Explorer 7

They’re both available for Windows XP. ‘Nuff said.

Sidebar

I’m not a big fan of the Vista Sidebar personally, but if you like the concept of having some widgets or gadgets or whatever you want to call them running on your desktop, then you can check out Konfabulator Yahoo Widgets engine. It’s not exactly sidebar, but the widgets it can run is very similar to Vista Sidebar gadgets. Apparently the Google Desktop sidebar also has the capability to run Google gadgets, so that’s another option.

Initially when I tried to implement this sort of thing I used the "keywords" field. I would just add the tag to that field, then I created Smart Playlists based on that field. This post at Lifehacker suggests using the "Grouping" field, but the premise is the same.

This approach works fine until you want to edit a bunch of songs and add a tag. When you do a bulk edit of the keywords field in iTunes it’ll overwrite anything that was there previously. So suddenly tagging all that music with "Sasquatch 2006" removed all the other cool tags you had applied. Major suckage.

Today I decided to try a new approach: I just use dumb, old-fashioned playlists. When I want a new tag, I create a new playlist for it. For organization purposes I keep all tag playlists in a folder called Tags. I can then create additional nested folders for categories, and because of how iTunes handles folders with playlists inside, the folders will become aggregators of all the music in playlists underneath them, which is nifty. This means I can see all of the music I have tagged just by clicking the Tag folder

This approach is pretty simple. Adding a tag is easy, and using the tags to drive smart playlists is easy too. Just add an "If <Playlist> <is/is not> <Tag playlist name>" clause to the Smart Playlist. There is a drawback, though… Removing tags is now a pain. From the frying pan into the fire… I have to make sure the song doesn’t appear multiple times in a playlist, and if it does, remove all occurrences. This is because playlists are designed to support multiple occurrences of the same song. If I want to start and end my playlist with My Heart Will Go On, then dang it, I can do it. But for my purposes, it’s not the ideal behavior.

Anyway, none of this really helps my situation, because the iTunes app doesn’t help me manage my tags, build playlists based on them, or anything, natively. All of this is a hack. There are a lot things that it could do to make it easier to tag music. And with the iTunes music store, what if I could check out how other users were tagging the track, and borrow their tags? This is all stuff that is provided by Last.fm, of course, but Last.fm doesn’t manage my entire music collection - iTunes does.

And of course none of this does anything on my iPod. Heck, it can’t even understand playlist folders, which is super super super dumb. Actually, I have a lot of gripes about the iPod UI… maybe a post in Rants is in order…

I’m talking about syncing to the device using the wireless. Sounds cool, right? You just walk into your apartment, turn on the Zune, and Boom! All of your music is synchronized to it. But what people don’t seem to realize is how slow this would be. The maximum bandwidth for USB 2.0 is 480 Mbit/s, or 60 MB/s. 802.11g, on the other hand, has a maximum raw data rate of 54 Mbit/s, or about 24.7 Mbit/s net throughput. Now, by applying some simple mathematics:

480 / 24.7 = 19.4332

This means that syncing to your device using wireless would be roughly 20 times slower than using USB 2.0. Even if we assume the theoretical max data rate for 802.11g, which isn’t realistic, to be clear, you’re still looking at a transfer speed that’s ten times slower. And don’t even think about using 802.11b. Frankly, this doesn’t sound like a good idea.

"So what?" you say. "I can leave the Zune syncing all night and it’ll be ready to go in the morning. Speed isn’t a real issue." OK, fine. You walk into your apartment, you turn on your Zune, and it starts syncing. You go to bed. You wake up the next morning, and your Zune is finished syncing, but it’s battery has also been drained. Good luck using it on your commute.

So what do you do next time? You plug it in so it can charge while it’s syncing. But at this point, why not just plug it directly into your computer to sync and charge at the same time, at a much faster rate? So to me, it’s clear that isn’t really a desirable feature, and I’ll bet that some Program Manager on the Zune team came to the same conclusion.

One thing that I will point out, however, is that many times, when you sync, you’re not syncing that much data. Your library hasn’t changed that much, and the only thing that’s being synced is play counts or updated track info or something. In that case, this feature might make sense. The amount of data wouldn’t be large, so the process wouldn’t take long and the battery drain would be minimal. There might be some scenarios where this feature would be useful. However, I think that a lot of people had a knee-jerk reaction and haven’t really thought through the ramifications and technical limitations of that feature. But hey, that’s what we PM’s get paid for, right? :-)

However, this post is really meant to be about Microformats, an interesting little technology that allows you to add a bit more metadata to existing markup, ostensibly to provide a better way to work with that data and leverage it in unique ways. I learned about it at the Gilbane Conference a couple weeks ago, and I wanted to do some checking to make sure you could leverage them on your MOSS site if you wanted. Seems like you can, as this post suggests.

If you view this post in Firefox you’ll see a little icon next to Patrick’s picture above. This is done using CSS, but you won’t see it in IE because IE doesn’t support :before and :after. But anyway, this isn’t all that interesting, because I could already do that using CSS. What is interesting, however, is if you go to http://inside.glnetworks.de/2006/06/05/microformats-have-arrived-in-firefox-15-greasemonkey-06/ and download the Greasemonkey script there. Then return to this page, and you’ll see that miraculously the following menu has been added above Patrick’s name:

Nifty, huh? If you’re using that same Greasemonkey script you’ll also notice that the text above about standing in line to get a Wii at Target is an event that you can add to your calendar:

All of the data in the sentence I wrote is wrapped in some appropriate tags that a compatible client reader (Firefox + Greasemonkey script in this case) can parse out and act on. Plus, because it’s well-known markup, there’s a nice backwards compatibility story for downlevel clients. For example, looking at this page in IE is pretty boring, but stuff lights up when you use Firefox and the script.

Anyway, this all goes to show that there is a lot of opportunity for Microformats to take off if there’s better client support. Just consider RSS - now browsers inherently know how to read some markup in the header of the page and automatically detect RSS feeds on a page. It’s not hard to image a time when Firefox will include the functionality currently offered through the Greasemonkey script natively. Plus there’s some great tools already out there for dealing with this type of data. Just check out this link to Technorati, which will automatically parse out the hCards on this page and let you download them as vCards.

I could also write some code that runs on the server and outputs special JavaScript and CSS when Microformats are encountered. Then no client side support would be necesarry. I’ll be looking into this in the next few weeks. Anyway, I think there’s a lot of potential to include Microformats in more places on my site, so keep your eyes peeled. :-)

http://www-128.ibm.com/developerworks/java/library/j-jtp09275.html?ca=dgr-lnxw01JavaUrbanLegends