The Software Devotional

Zen and the Art of Loose Coupling

The volume of responses to my previous article about loose coupling was crazy. It wasn't just the volume - the responses were all over the place. Some of the themes of the comments really surprised me. Some readers vehemently agreed with me, other suggested that loose coupling isn't as big a deal as I made it out to be, and others suggested that there were other areas where I should have focused my attention.

By far, the heaviest volume of responses came from readers pointing out that too much loose coupling is a really bad thing as well. I don't disagree with this point - I even made this point in my post. However, as I replied to some of the authors, I WOULD LOVE TO BE STRUGGLING WITH TOO MUCH LOOSE COUPLING instead of being crippled by too little loose coupling. Making code more tightly coupled is ALWAYS, ALWAYS, ALWAYS easier than modifying tightly coupled code to be more loosely coupled. Besides, I just don't see nearly the incidence of overly loosely coupled code - it just isn't out there to the same degree as tightly coupled code. Not only that, but it just isn't as painful an experience to deal with.

It's an odd thing - my previous post about unit testing has been a big source of short term contract jobs for me. In this capacity, I have been called upon to help with all sorts of unit testing projects from helping to get unit testing kicked off for a project, help write unit tests, and just helping out with understanding how best to use unit tests to increase software quality. Many of the projects I see are nearly untestable, unstable, and difficult to change because of the high likelihood of breaking the project. I see people that are afraid to make changes to this sort of code, which makes it difficult to make needed changes to these projects. In the unit testing article mentioned above, I made the point that a homing beacon for poorly written software, especially tightly coupled software, is that it is difficult to unit test. Count on it.

Let me say it again: like everything else, loose coupling is a balancing act. A good architect will find his Zen for loose coupling and can be a good guide. In many cases, knowing how and when to loosely couple your software will be a mostly intuitive process for someone with years of experience. However, casting error on the side of more loose coupling than you might need will give you a more maintainable and easily tested system than by leaning toward more tight coupling.

Before moving on, I have to admit that I haven't given props to the contribution of cohesion in the role of maintainable software. I'm not going to try to explain it better or more concisely than the cohesion wiki: "cohesion is a measure of how strongly-related and focused the various responsibilities of a software module are." I have more to say about the role of cohesion in quality, but I will save that for another post.

Ideally, we will find a balance between the two extremes (loose coupling and tight coupling), but I'll take software that is too loosely coupled over software that is too tightly coupled - every time.

Resources:

• If you want a more elaborate analysis of cohesion, study the sample chapter from the book The Practical Guide to Structured Systems Design. The chapter does a good job illustrating the differences between the various forms of cohesion.
• Also, the book mentioned above, The Practical Guide to Structured Systems Design, is a great resource for architects looking to understand how to build maintainable software. It leans heavily toward an academic view of software (that's not all bad), and is very long-winded in parts.
• WWMFD? Martin Fowler is always a good source for software-related thoughts. He published an article way back in a 2001 issue of IEEE Software titled "Reducing Coupling". When in doubt, ask yourself What Would Martin Fowler Do?
• By "maintainable software" (I used this nebulous term above), I mean software that is relatively easy to understand, troubleshoot, modify, extend, and test. I include this definition here to direct you to a post by Jeremy Miller where he points out several qualities that make software difficult to work with. His post is well worth your time to read.

devLink 2009

Tennessee developers: registration opened on April 1 for devLink 2009. devLink is a software development conference held in Nashville every year - this year it is scheduled for Thursday, August 13 through Saturday, August 15 and will be held  at the David Lipscomb University campus. Like the big national conferences, devLink provides great session content by great speakers. But unlike the big national conferences, devLink limits attendance (this year to 800 attendees) and its non-procrastinator price is only $75 (goes up to $100 after April 15). Register now because it sells out every year.

devlink is organized by John Kellar: speaker, developer, blogger, and nice guy.

devLink is one of a growing number of "local" conferences being organized all over the country. In general, they are on similar footing as VSLive, DevConnections, and the SD conferences in terms of content, but lack the big-budget venue and marketing blitz. This appeals greatly to me because I dislike the travel expenses of getting to the conferences and because many of the national conferences slant session content toward the material being pushed by the big marketing departments of Microsoft, Oracle and the like. The "local" conferences that come to mind (without Googling) are devLink (Nashville, TN), CodeStock (Knoxville, TN), and CodeMash (Sandusky, OH). Check them out and attend the one that's most convenient to you.

If you know of any that I've missed, please let me know by posting here or emailing me.

Amazon Web Services April Fools Comes Early

Not without a sense of humor, the Amazon Web Services group posted about a great new service it will soon be offering, if but for a single day (Apr 1). Based on customer feedback, Amazon has "designed and [is] now introducing the Floating Amazon Cloud Environment, or FACE for short" to deliver "durable, unmanned helium-filled blimps with a capacity of 65,536 small EC2 instances, or a proportionate number of larger instances." An additional feature added for the FACE environment is support for RFC 1149, which describes a "method for the encapsulation of IP datagrams in avian carriers." Go Amazon.

Colibri

I have experimented with several productivity tools to aid with quickly launching applications. I hate clicking the start menu, selecting All Programs (I use Windows XP), and then finding my application in the long list of installed applications. I have optimized my Quick Launch toolbar, my Start Menu, and have even created toolbars that lurk in my taskbar that link to folders with commonly used shortcuts.

The problem is still that they are all require me to drag my mouse around and poke the required menu items. Using the mouse, especially when you interact with large menus, is a real time drag. I know the Windows Start Menu supports shortcut keys, but honestly there are only so many of those I can remember. I have found a better way.

Colibri is a free, hot-key launched, keyboard optimized, launcher utility. If you've ever seen QuickSilver on the Mac, this is very similar. I hit Ctrl+Alt+Space (configurable) and the Colibri console appears, center screen. I start typing text contained in the name of the application or file I want to open and Colibri finds the item and opens it. No mouse interaction is necessary. None. It will not even let you.

In the example on the right, the underlined text in the top pane shows that I typed "word" into Colibri's main window. Since this was the first time I typed this text, it offers a list of all the items containing the search text. After I type the text and select the application I want to launch (Microsoft Word in this example) using my arrow keys, Colibri remembers my selection. The next time I type the same text Colibri recalls my previous selection and suggests it as my first launch option. Hit Enter to launch the selection. If you use multiple applications that contain the same text, Colibri will keep them at the top of the list for easy selection - the selection you used last will be automatically selected.

There are several features that I really like about Colibri that set it apart from other application launchers. First, unlike many of Colibri's competitors, it has been extended using plug-ins to support launching many different file types. Among my favorites is the ability to open Control Panel applets. When I type "Add" into Colibri, Colibri selects the "Add or Remove Programs" control panel applet by default. This saves lots of time over waiting for the Control Panel list to populate.

Colibri also supports quick Google searches. Enter the Colibri hot-key, type "Goo" and select Google (if it isn't already selected). Then hit Tab and start typing your search text. When you hit Enter, a browser window opens to the Google search page executing your search. The hot-key search feature of Google desktop is better than Colibri (fewer keystrokes), but I don't run Google desktop on my laptop.

Beyond just launching applications, my favorite Colibri feature is its support for launching shortcuts of ANY type. It takes a bit of work, but using the free SQLite Database Browser available on Source Forge, the configuration files for Colibri can be modified to instruct Colibri to scan additional directories for files that can be launched. A favorite practice of mine is to add a directory in My Documents containing shortcuts to my most commonly accessed directories. I name the shortcuts using the name of the machine (if it's not local) and the directory names (such as "appserver01_bin_net_dll") so that I can quickly type the machine name and folder I want to open - Colibri finds it quickly and saves me time typing the path in Windows' Start/Run application. In the example below, I entered the text "apps dll", and Colibri narrowed the list down to two machines that both contain a directory with "dll" in the path name.

Here's how to add a new directory to Colibri's list of scanned directories. Open the SQLite Database Browser application and open the "Filesystem.sqlite" SQLite database found in your Application Data\Colibri directory. Open the table named "folders" - the folders table contains 1 column named "path". Add a row containing the full path to the directory you want Colibri to scan.

After modifying Colibri's configuration files and after you add a new shortcut to a scanned directory, you will need to tell Colibri to rescan the directories. Hit the Colibri hot-key, enter "Colibri" and hit Tab. Use your down arrow to select the "Update Index" option. It should take only a few seconds before you are on your way again.

If you are a Visual Studio user, I suggest changing the default hot-key to Ctrl-Alt-Space because Visual Studio uses Alt+Space (Colibri default) for IntelliSense support - easy fix.

Don't walk away with the impression that I am suggesting that by simply using Colibri you will transform yourself from a non-productive programmer to a productive programmer. There are many more factors that will affect your productivity much more than how you launch apps on your computer(procrastination, email, telephone, instant messaging, YouTube, Facebook, sports, desktop clutter, etc.). Colibri will help you navigate your computer faster than you were previously able - guaranteed.

SimpleDB Explorer on Bits du Jour This Sunday

Do you remember the days of having to create tables, add columns to tables, and query the database using text-based SQL tools to do it? My college professor made us do it that way so we would learn SQL. When I used the database management tools for the first time, I was disappointed to find that they weren't a lot easier to use (maybe because I had gotten so good at using SQL, but that's another discussion). Dang that sucked. Thankfully, things have gotten a lot easier since then.

I got to taste my disdain for the lack of tools for new products in the early days of programming using Amazon's SimpleDB. It was right back to the days of old - no good tools. I came across SimpleDB Explorer a couple of months ago and I love it. SimpleDB Explorer is essentially SQL Server Management Studio for SimpleDB databases (better in some ways). If you use SimpleDB, you should give it a try.

So, the reason for this post: I just noticed that SimpleDB Explorer will be on Bits du Jour on Sunday, March 1. Bits du Jour helps software vendors market themselves by pushing great software at insane prices. The normal price of SimpleDB Explorer is $34.95 and Bits du Jour will be selling it for $19.95 this Sunday only.

If you don't know much about SimpleDB Explorer, try out their 30 day free trial this weekend. Then buy it on Sunday.

Check out some screen shots of the product on the SimpleDB Explorer web site.

Post back here if you liked it.

Loose Coupling is Good - Tight Coupling is the Devil

I have been struggling for some time to explain to fellow developers the merits of loose coupling. It's usually a hard argument to make. To argue for loose coupling, it is necessary to overcome the arguments against it: high degrees of loose coupling in otherwise small projects (small number of classes, small number of developers, little dependence on third-party tools, few database tables, very short development cycle, etc.) is almost never going to give much bang for the buck. However, as software projects mature, an architectural tenacity toward loose coupling in the early stages of a project can mean big (BIG) payoffs later.

Why don't more developers embrace loose coupling? To be sure, it's harder than tightly coupling your code. From the average developer's perspective, tighter coupling means that features are coded faster, bugs are squashed more quickly, direct relationships between objects are easier to conceptualize for architects and easier to visualize for developers, IntelliSense for .NET developers works better, and problems are tracked down more quickly. Try arguing against all that! The truth is, direct relationships between systems and components simplifies life on smallish projects. However, as a project grows, tight coupling will likely cause some of the most painful growing pains you will face as a software developer.

What is Loose Coupling?

If you're still scratching your head because you don't quite understand what loose coupling is, there are lots of reasonably good definitions on the web (this is a pretty good one and this one is even better if you don't mind the academic slant). In short, loose coupling is a design goal that seeks to reduce the interdependencies between components of a system with the goal of reducing the risk that changes in one component will require changes in any other component. Hold on, isn't this is same tired idea my 1st year computer science professor called encapsulation? Got it, thanks. Not exactly - encapsulation in an OOP sense generally aims to guide (or force) users of your components to use your classes correctly and makes it harder to abuse the class's functionality by hiding the implementation. Loose coupling is a much more generic concept intended to increase the flexibility of a system, make it more maintainable, and make the entire framework more 'stable'.

How do you measure coupling? Not easily, I'm afraid. The degree of coupling between two components can be qualitatively measured by determining the effects of changing the contract or interface between two components or systems. For example:

• What would happen if you added or deleted a property from a class?
• What would happen if you changed the data type of a column in a table?
• What would happen if you added a column to a table?
• What would happen if you changed you asynchronous email component?
• What would happen if your database server changed from SQL Server to mySQL or Oracle?

The degree of pain that each of these changes would cause you is a good qualitative measurement of how tightly coupled your components are to the components they depend on.

Symptoms of Tightly Coupled Systems

If you have ever deployed a seemingly innocuous change only to find that other parts of your system broke when you did, then you have likely experienced one of the chief symptoms, in my experience, of tight coupling. If you have ever experienced a problem where it was hard to fix a problem because of the number of changes to other components that were required to make the change safely, then you have experienced the symptoms of tight coupling. If you find yourself repeatedly choosing "the poor man's solution" because the real solution was just too risky or required too many components to change, then you were likely the victim of tight coupling.

For the reasons I gave previously, tight coupling generally speeds the development of smallish projects. The pains caused by tight coupling aren't generally felt until the project starts to grow. As features (and developers) are added to a project, the original design purity grows cloudy in imperceptible increments. The pure evil of tight coupling becomes most apparent once the product has grown in the number of features that have been bolted on and has expanded past the first few developers that set the vision for the project's architecture.

The problem is, it is only when you have reached the stage in a project when you are feeling the pains of tight coupling that it is reaching the stage where it becomes very difficult to remedy. This is why tight coupling is such an insidious problem - even experienced and otherwise conscientious developers will be lulled by the comforts of tight coupling. It feels good. Control just feels nice.

Because your earlier design and coding choices have led to a system that is difficult to maintain without considerable grief, tight coupling is a notorious form of technical debt. In fact, in my experience, a considerable portion of redesign-from-the-ground-up projects are initiated because of high degrees of tight coupling making incremental improvement seemingly impossible or impractical (but resist this temptation at all costs).

Loose Coupling In Your Projects

Let's make sure we are on the same page. You can never completely loosely couple everything - that's a given. At some point, some part of your software will be VERY tightly coupled to something else. The point isn't to loosely couple everything. The primary goal is to reduce the amount of work and the risk involved when you change the interfaces between components of your system. Using this as our goal, we should look for areas where changes will cause lots of downstream work. You also need to consider the likelihood that changes to a particular system will occur. Face it, most people aren't going to change their database servers often, so maybe that's not your main focus. However, the licensing tool, EDI message parser, logging framework, email product, etc. are all great candidates for loose coupling.

Look a little closer - you will also find that there are interfaces between the components inside your software that should be loosely coupled. In fact, these are likely to be the areas of tight coupling that are the most difficult to fix.

Very simplistically, you should look for ways to maintain a consistent interface that hides changes that occur. If you send email notifications from your software, a loose coupling approach would be to build an interface around your email component of choice exposing only the functionality you need for your application. If done correctly, you could easily change email component providers with few changes to your application. In this simple example, only the implementation of the email interface wrapper would need to change - create an object of a different type, set different properties, and call a different method to send the email. By loosely coupling, we didn't eliminate all the work required to make a change, but we were able to isolate the work to a very manageable, easily testable, low risk, and quickly implemented project.

Keep in mind that loose coupling comes at a price. Consider these issues:

• Consider the cost of implementing loosely coupled interfaces versus a more tightly coupled solution. For sure, loosely coupled interfaces mean not only more code but also more complex code.
• Tightly coupled interfaces are easier to conceptualize for architects, easier to code for developers, and easier to troubleshoot when problems are suspected.
• The cost of tightly coupled interfaces will be measured in frustration, not necessarily in the developer time it will take to fix the tight coupling. However, ghastly amounts of developer time and increased project risk are two of the usual suspects. With tight coupling, you will find that seemingly simple changes turn into complex coding projects and become very difficult to test.
• The cost of uncoupling tightly coupled interfaces down the road can be very costly and will likely be very risky.
• How likely is it that a tightly coupled interface will need to change in future versions of your code.

As you get a good feel for loose coupling, you will actually learn to take advantage of the looseness of the application. The looseness that you will exploit will be the same parts that traditionally make loose coupling more difficult. Consider being able to make components of your system pluggable - you could replace pieces interchangeably. Consider how testing a large application could be made more simple if you replaced a complex business object or data layer object with a simple mock that would enable test cases to exercise other components of the system.

Evolution of the Software Developer

In a great blog post from last year, Jeremy Miller chronicles the maturation process of a software developer from the perspective of loose coupling. Most experienced developers have intuitively known about this progression even if they couldn't put it into words. To paraphrase, Jeremy explains that developers start with the "Just Make It Work" philosophy, fixing problems wherever they realize there might be a problem. Quickly, the developers who wriggle out of the primordial coding goo and begin to realize that there are 'correct' places for things, and strive to put things in their 'correct' place. Still more time passes and these same developers begin to realize that loose coupling is important in all but very simple projects. For those developers who live long enough, their loose coupling fu evolves naturally into the use of inversion of control.

To help get you further along the path, work through thought experiments to consider how you will change systems later and how you will need to go about making the required changes. As you do, weigh the costs and benefits of loose coupling.

With any luck, in future posts I will work through some concrete examples of places where you should consider loose coupling and how to implement it.

Warning About Using Extension Methods

In an article I published at DevX about some of the new features in VB9, I described how you could use extension methods, which are a new feature available in VB9, even in projects targeted at the .NET 2.0 framework. When I first read about extension methods, my mind began racing through all the features I wish various classes and products had implemented. A short list of the extension methods I implemented and used frequently are described below.

• IsSomething(Object) and IsNothing(Object): These methods make it easy to check object references.
• SafeString(String): This method always returns a string. In the event that a string was set to Nothing, it returned String.Empty. An overloaded version of the method also accepted a default value that would be returned when the string was set to Nothing.
• SafeDBString(SQLDataReader), SafeDBInteger(SQLDataReader), etc: These methods allow safe access to fields returned in a result set. In most cases, when I want to read a string from a database, especially for display, I want an empty string instead of DBNull. This method does this neatly and concisely.

I know there are various ways to implement these methods without using extension methods, but the dot syntax used when you call extension methods appeals to me. The syntax of strMyString.IsNullOrEmpty() seems more natural than String.IsNullOrEmpty(strMyString).

That said, I will offer you a warning that my article referenced above did not mention. If 1) you work in an environment where classes containing plumbing code, business classes, and the like are created, and 2) you have used extension methods created in .NET 2.0 projects, you will find yourself in a sticky situation when (if) you decide to use those classes from a .NET 3.5 project. The problem is caused by duplicate definitions for the ExtensionAttribute: one in your .NET 2.0 project and one in the .NET 3.5 framework.

When you attempt to compile a .NET 3.5 project with references to duplicate ExtensionAttribute definitions, the build output console in Visual Studio doesn't show a specific error. It merely indicates that the build failed. If you attempt to build the project manually using command line tools, the error message looks like the output below.

Microsoft (R) Visual Basic Compiler version 9.0.30729.1
Copyright (c) Microsoft Corporation.  All rights reserved

InternalXmlHelper.vb(9) : error BC30560: 'ExtensionAttribute' is
ambiguous in the namespace 'System.Runtime.CompilerServices'.

<Global.System.Runtime.CompilerServices.ExtensionAttribute()> _
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If you have the luxury of upgrading your entire code base to .NET 3.5 at one time, then you will be safe. Simply remove the 'hacked' ExtensionAttribute definition from your code. When the projects are recompiled, references to the ExtensionAttribute will naturally pick up the definition provided in the .NET 3.5 framework.

If you run in a mixed environment, like I do most of the time, then you will run into the problem that the ExtensionAttribute will be defined both in your .NET 2.0 project (as described in the DevX article) and in the .NET 3.5 framework. This will prevent you from compiling any .NET 3.5 projects that reference any of your .NET 2.0 classes that use extension methods. Keep in mind that this means that any project that contains the .NET 2.0 assembly where you 'hacked' a definition for ExtensionAttribute, even if it is an indirect reference (you reference an assembly that references it), cannot be referenced by a .NET 3.5 project until the 'hacked' definition is removed.

Extension methods are still useful in some smaller projects where the entire project will be upgraded to .NET 3.5 at one time. Extension method users beware: if you work in an environment where you have multiple versions of .NET assemblies in use, you are heading into a world of pain.

SmugMug is the Premier Photo Sharing Site for Geeks

I take a lot of pictures and I am a total geek when it comes to organizing my pictures (and audio files). I have pictures going back to the first images that appeared on my Olympus C-700 Ultra Zoom back in early 2001. I got a relatively late start to digital photography, but 37,951 pictures, 1798 directories, and 67.98 GB later (at last count), I have a lot to protect and manage.

I have this obsession with being able to find any picture I have ever taken within just a few minutes. I have every picture (and video) organized into individual directories for individual events. An example might be "2008.05.11 - Hiking at Radnor Lake - Nashville, TN".

You might expect that I would have found a good tool to help me with this by now. However, try as I might, I have never trusted any of the photo organizer tools that are available. I have tried lots of them: ACDSee Photo Manager, Adobe Photoshop Album, Microsoft Picture It 10 Library, Corel Photo Album, ULead Photo Explorer, and more. Most of them worked decently, had sharp interfaces, and some had some neat features that set them apart from the others. However, having seen many programs come and go, many of them requiring me to allow them to organize my photos using the program's specific storage methodology, I have always been hesitant to turn over the management of my photos to a tool that might not be around when I am looking for a good embarrassing picture of my son to show at his wedding reception 10 or 15 years from now.

So, I stick with my un-trusting and archaic means of managing my photos. They sit on my machine, where only I can get to them. One of my wife's constant complaints is that of all the digital pictures we have, I have rarely taken the time to print any of them (I don't know what I would do with them if I did). I have a slide-show of my photos running on my ReplayTV (pre Tivo device, and better) when my TV shows are paused, on two digital photo frames, on all of my family's 5 iPods, and in my Vista Sidebar gadget (because I was stupid and bought Vista). But no prints.

My biggest problem is getting these pictures into the hands of my wife and family members who want to see them and sometimes order some prints of them.

SmugMug

A little while back, I discovered SmugMug. In a nutshell, SmugMug is an online photo management tool that allows you to upload ALL your photos (and optionally videos), organize them into galleries, and share them as you like. They offer unlimited photo storage, unlimited traffic, with no ads and no spam. SmugMug offers a 14-day free trial, but doesn't have a free version. The Standard versions costs $40 annually, and the Power version costs $60 annually. The big difference between the Standard and Power version is support for DVD quality video (limited to 2.5 minutes). Beyond support for video, the benefits of upgrading to the Power account are listed below.

• You can create a custom hostname for your SmugMug account. Direct people to something like photos.MyDomainName.com instead of MyAccountName.smugmug.com. Not terribly important for sharing photos, but a nice touch for the real geeks.
• SmugMug helps protect your photos from right-click downloading by viewers.
• Change the look and feel of the site and modify the headers and footers of your page. Some of the customized sites I found would be somewhat difficult to identify as SmugMug sites to someone not intimately familiar with the SmugMug site.

If you haven't seen SmugMug recently, visit it now and browse around a bit.

I have used SmugMug for a while now and love it. It isn't perfect, but it is better than the handful of other sites I tried before devoting myself (for a while anyway) to SmugMug. I bought a Power account for the video support and I I love the custom domain name.

My Favorite Features

• Uploading photos and video is a breeze. SmugMug supports 8 upload utilities, although I use the Simple one (that's what they call it). It is a Java utility that allows you to select individual files or an entire folder and it uploads them, in full resolution, very easily. Because of the photo directory naming convention I described above, this is especially helpful for me.
• The interface is the best looking in the industry. Slick use of AJAX makes the site smooth and fast. The pages download extremely quickly and the pictures load nearly instantly - great overall user experience.
• The galleries show large pictures that make it easy to quickly find a picture. In addition, other users (my family mostly) can subscribe to RSS feeds to be notified of new pictures posted to my site.
• I host a blog on TypePad for my extended family to keep in touch with the goings on of my family. It is mostly a digest of our family's activities, but I always post pictures throughout the post along with a link to the SmugMug gallery for the event. All standard stuff. SmugMug makes it extremely simple to  do this with a 'sharing' page that displays several links to various sizes of each picture. I go into a gallery, select the picture I want to display on my blog, and click the Sharing button. This brings up a page (actually an AJAX frame) displaying links to 8 different sizes of the picture I selected, from tiny (up to 100 by 100) to what SmugMug calls X3 Large Link (up to 1600 by 1200). When I click the link for the picture that I want to show on my blog, the URL is automatically copied to my clipboard (nice touch). For the pictures I show in the blog post, I typically use either thumbnail or small. At the bottom of the blog, where I link to the gallery, I use one of the 3 links provided on the sharing page that brings the user to the gallery where the selected photo was stored. The sharing page is one of the many small touches that helped me to choose SmugMug.
• The granular security provided is helpful. Since most of my site was created mainly for the purpose of sharing photos with my family, I have my site set to Public, meaning anyone with a link to it can view the photos. In addition, I elected the following settings: Google will not index my galleries and other SmugMug users cannot find my galleries when searching the SmugMug site. In short, if you find one of my galleries via a link from my family's blog post, you can see all the pictures, but no one else is likely to happen across them accidentally.
• SmugMug also allows friends and family members to modify the keywords and comments associated with pictures. This has been a nice feature as it helps to ensure that some of our better pictures get the captions they deserve.
• There are lots of choices for displaying your photos. SmugMug lets you select a different theme for every gallery, allowing you to really 'set the mood' for the occasion. As of Dec 2008, there are 50 to choose from.
• Unlike most sites, you can arrange the pictures in your gallery the way you want them to appear. Normally, I am happy leaving the gallery alone, allowing it to display the pictures in the order they were taken. Sometimes though, there are a few pictures that you want to make sure everyone sees. SmugMug has an Arrange mode, which allows you to drag photos in the gallery to other locations - I sometimes like to take 1 or 2 of the my photos in a gallery and move them to the top of the list.

So far, SmugMug hasn't replaced my local storage methodology for pictures, but it does solve several of the problems that I have made for myself. Chiefly, my family members (Mom, Dad, brothers, grandmothers, etc.) can see what we are up to from week to week. From the monkey-off-my-back department, it also allows my wife and Mom to print the pictures they want without my intervention.

If you a professional photographer, there is also a Pro version available as well for $150 annually. You can modify the site very extensively to make it your own. You can sell prints with profitable markups, sell digital downloads of the prints, and display HD quality videos up to about 10 minutes in length.

Wish List

That said, there are some things I don't particularly like about SmugMug.

First, I have had infrequent problems logging into the site. It does not always keep me logged in, as I expect, and when I enter my email address and password and click login, the page to which I am taken operates as though I have not logged in. It seems that this problem could be easily remedied.

Second, the site seems to be unstable a little more often than I expect - the problems are rare, just more often than I expect. When the site is obviously having problems, sometimes I get an error message that lets me know they know about the problem (which is somewhat of a relief), but more often there is no notification.

Another quirky issue I have is with uploading. After I select a group of pictures to upload, I click upload and continue doing something else. Almost every time, I come back to it and find that one or more of the pictures has not uploaded. Ready for this, SmugMug has added a Retry button that retries all the failed uploads, but I sometimes need to click this button more than once to get all the files to upload successfully.

Like I said above, I love my custom hostname I use to access my SmugMug account. However, throughout the site, I find that the URL has reverted from my custom hostname (something like photos.MyDomainName.com) to the standard hostname (MyAccountName.smugmug.com). It isn't a huge problem as all the links work and the navigation is seamless, but it is aggravating that the site can't keep my URL stuck on my custom hostname. Having paid for the Power account, I expect my custom hostname to be used throughout.

Navigation seems to be a little clumsy. It seems that navigation around the site was added as an afterthought. When I am viewing a gallery, the high-level navigation links at the top of the screen disappear and you are required to use the breadcrumbs links to find your way back to the list of galleries. I have learned to get around very easily, and I think most people will quickly do the same, but it was initially very non-intuitive. I fear that it will be an issue for my Mom.

I will update this post if the status of the items on my wish list change. Check back.

Overall, as I said at the top of this post, SmugMug is easily my favorite photo sharing site on the web.  It has some shortcomings, but I have learned to live with them for the greater good.

Read the rest of the SmugMug story in a 2007 Los Angeles Times article.

Give SmugMug a try.

GUID Visualizer Broken in VB.NET and How to Fix It

A colleague brought over a strange problem he was seeing while debugging a VB.NET project. During a debugging session he hovered his mouse over a variable of type System.Guid. You normally expect the standard visualizer for the type to appear, but it was displaying "Empty". Unfortunately, this led to some thrashing and gnashing of teeth because this 'bug' caused him to incorrectly suspect a problem with his code.

After a bit of searching and reflecting over the System.Guid class, I found that it is the visualizer for GUIDs in VB.NET that is 'broken'. The 'bug' exists in both Visual Studio 2005 and Visual Studio 2008. Dang.

Here is what the problem looks like out in the wild. In VB.NET, the visualizer tricks you into thinking that the value of the GUID is Empty.

When you call .ToString on the GUID, there is clearly a GUID populated.

I ran the *same* code in C#, and it works perfectly. +1 for C#!

 

Microsoft left a bug in the two most recent versions of Visual Studio? Not really.

When I found that the GUID shows up correctly when you call the .ToString method, I realized that the GUID is populated, it just doesn't appear correctly in the debugger. This led me to believe that there must be something else going on. I got out Reflector to take a look at the System.Guid class and found the problem.

As it turns out, the System.Guid class contains a single read-only property named Empty. Because the Empty property shows up in the debugger visualizer as the only member, it has the effect of making you think that the value is empty. To make matters worse, the Empty property returns an empty (all zeros) instance of a System.Guid class. The result, when you drill into the System.Guid variable: you get a never-ending tree of what appears to be Empty GUIDs.

We can't blame the visualizer specifically. The word Empty is misleading and leads developers to believe that a GUID variable is empty - the "not used" type of empty.

You can work around this problem by downloading a visualizer for GUIDs (from here and here).  Both of these visualizers give you the option to open a window in the debugger displaying the GUID's value. A little cumbersome.

Here's how you can create an even better GUID debugger visualizer on your own.

Create a VB.NET class library. If you are using Visual Studio 2008, make sure to target the .NET 2.0 framework. Create a new class and put the code below into the class file. The class and project names do not matter.

<assembly: system.diagnostics.debuggerdisplay(="" {tostring}="" ,="" target:="GetType(System.Guid))">
Public Class Visualizer_GUID
    '---- no implementation necessary
End Class

Compile the code and put the output in your "My Documents\Visual Studio 2008\Visualizers" and/or "My Documents\Visual Studio 2005\Visualizers" directories. Crank up another Visual Studio project, create a GUID, and hover over it in debug mode. Here's what you will see.

Now that's much better.

You can download my project and compiled class library here (11.3K).

Free SimpleDB Pricing and Public Beta

Free SimpleDB Pricing Tier

Though the announcement showed up in my mail today, Amazon announced yesterday that a new free pricing tier will be made available for its SimpleDB service. According to Amazon's SimpleDB page, the first 25 machine hours, 1GB of data transfer, and 1GB of data storage used each month will be free of charge for at least the first 6 months (starting Dec 1, 2008).

From Amazon: You can get started with SimpleDB for free and without risk. For at least the first six months of the public beta (starting December 1, 2008), you pay no charges on the first 25 Machine Hours, 1 GB of Data Transfer, and 1 GB of Storage that you consume every month. In most use cases, approximately 2,000,000 GET, QUERY, or QUERYWITHATTRIBUTES API requests can be completed per month before incurring any usage charges. Many applications should be able to operate perpetually within this free tier, such as a daily web-site analysis and traffic reporting tool, a web indexing service, or an analytics utility for online marketing programs.

I have read elsewhere that this process is being spun as a
'trial' for the SimpleDB product. I don't believe that Amazon views this free tier as a traditional trial period and I don't think they are trying to convince more people to help test their software while it is still in beta. It appears to me that Amazon is putting a toe in the water to determine how successful and how costly a free tier might be for SimpleDB. If Amazon can capture the hearts and minds of budding mISVs (when cost is a paramount concern), then they are likely to subsequently capture the pocketbooks of the successful mISVs as well.

In addition to the new free pricing tier, SimpleDB's monthly storage cost per GB has been reduced from $1.50 to $0.25 - 83%.  No doubt, this can be attributed to Google's and Microsoft's plethora of cloud computing announcements this year. Further, at $1.50, SimpleDB's storage cost was way out of line compared with S3's cost of only $0.15 per GB.

Recall that pricing for Amazon's SimpleDB is based on 3 factors: machine utilization, data transfer (in and out), and data storage.  After the first 25 machine hours (free), each machine hour costs $0.14.  The first GB of data transferred in and out are free, and the initial pricing tiers are $0.10 per GB inbound and $0.17 per GB outbound.  After the first GB of storage used per month (free), each additional GB costs $0.25 per month. A rough calculation shows the monthly savings to be a little under $4. Still, many web hosting providers charge several dollars each month for database storage - no need for that any longer.

SimpleDB Enters Public Beta Period

In conjunction with the news of the free pricing tier, Amazon also announced that SimpleDB, while still in beta, is open to all developers. The closed beta, opened to a select group of developers late last year, has given way to a public beta period.

This is good news for me, as I am speaking at VSLive in Dallas next week discussing, among other things, SimpleDB. I despise going to conferences to learn of technologies that have no hope of impacting my development environment for many months or even years to come. There is a time and place for learning how the future will shape up, but for a hands-on coding session, I personally think it best to have the technologies available at my fingertips. This makes SimpleDB available to all the attendees.

The Official Email

Dear AWS Developer,

Amazon SimpleDB is now available in public beta; any business or developer may now sign up and start using this service immediately. Amazon SimpleDB is a web service providing the core database functions of indexing and querying. We're also excited to announce a free tier of usage for SimpleDB, as well as lower prices for storing your data. In addition, Amazon SimpleDB customers will now have access to AWS Premium Support, providing access to a 24/7, one-on-one, fast-response support channel.

Pricing Updates

To help you get started with Amazon SimpleDB, we are providing a free usage tier for at least the next six months. Each month, there is no charge for the first 25 machine hours, 1 GB of data transfer (in and out), and 1 GB of storage that you use. Standard pricing will apply beyond these usage levels, and free usage does not accumulate over time.

In addition, beginning today, Amazon SimpleDB customers will now enjoy significantly reduced storage pricing, only $0.25 per gigabyte-month. This new rate reflects an 83% reduction in storage pricing. For more information, see aws.amazon.com/simpledb.

AWS Premium Support Now Available for SimpleDB

Customers can now also sign up for AWS Premium Support of Amazon SimpleDB. AWS Premium Support offers technical assistance from the Amazon Web Services team whenever and as frequently as customers need it. Whether for operational issues or technical questions, Amazon SimpleDB customers now have access to developer support engineers 24/7, and can count on predictable response time and personalized support. To sign up for AWS Premium Support, visit aws.amazon.com/premiumsupport.

New Features for Amazon SimpleDB Coming Soon

We are also very pleased to announce plans to release two enhancements in the next few weeks that will make Amazon SimpleDB even easier to use. These enhancements will include:

• SQL-like SELECT API: With this feature, you will be able to employ a very familiar SQL-like query language when constructing queries and building applications. The SELECT API will help you be more productive with Amazon SimpleDB right from the start.
• Batch Put: Enables you to streamline the upload of multiple items or attributes, with a single batch API request rather than multiple single item calls.

We are pleased to share these exciting announcements with you, and invite you to visit aws.amazon.com/simpledb for full details.

Sincerely,

The Amazon SimpleDB Team