Career Goals For The Next Six Months

Jason tagged me on this latest meme, but I’ve not responded to it in a couple days simply because I wanted to mull things over before slapping down something on my blog.

My career has had a lot of odd twists and turns over the last 13 years since I gave up flying around the world on one of these.  Much of that time has been me scrambling around trying to keep some sort of IT-related job while my wife dragged me (dragged!) to places like Bavaria, Washington DC, and Ohio.  Throw that in with 6.5 years as a work from home Dad and you may see that I’ve not been able to focus 100% on steering my career around right where I wanted it to go.

That said, I’m happy to say that somehow I’ve landed what I think is really my dream job working with a bunch of amazing folks at an amazing place.  (Despite not having seen the required movie.  James is still amazed I got hired having missed it.)

So what do I do to top that? Uh, get my act together and polish up the many rough spots I’ve got in my repertoire.

Improve My Testing

I desperately want to get rolling with FIT/Fitnesse.  I think this is an amazing tool that can really help turn the light on for customers and get them more intimately involved with ensuring what we’re building them is what they really wanted.  Goal: Get a great session together for my upcoming Grok talk at QSI at the end of this month.  Follow that by discussing using Fitnesse with at least one customer on a project in the next two months.

I also want to keep improving my skills with Rhino.Mocks so that I’m able to better test individual components.  Goal: Download and dig into the new features of Rhino within the next month.  This plays in to my next goal:

Improve My Use of Solid Patterns

First in line: the Model View Presenter.  I’ve not made as good a use of MVP in my current project as I’d like to and my code’s suffered for it.  I need to fix that.  Goal: Read at least four MVP articles over the next two weeks.  Roll that knowledge into future work.

Improve My Processes

Brian Button had a great post on getting rid of the pain points in your development processes.  If it hurts, do it more often until it becomes easy.  Sound words.  Goal: Fix a couple annoying build issues I have within the next two weeks.

Improve My Speaking

I’m stuck in the doldrums for topics which I’m interested enough to put together another speaking topic on.  I had a beer with Justin the other night and we talked a bit about possibly teaming on a CardSpace/OpenId gig, but I’m not sure if there’s enough interest and value in that right now.  I’d love to put together a great spiel to pitch for CodeMash, but my muse has abandoned me.  Goal: Come up with a solid topic for a good session some time in the next eight weeks.

Productivity

My productivity and velocity at work has been for shit.  Much of that has been due to starting a new job and getting back in the coding seat full-time after a LOOOOONG break.  While I’ve contributed a lot in the domain space, I need to carry my own weight in the actual delivery space.  Part of my low productivity has been a lack of disciplined focus with keeping my head down for longer periods.  Goal: Improve self-discipline for coding time, and improve my scheduling of tasks so I block out long periods for heads down time.

Improve My SharePoint

MOSS is a huge beast with some stunning potential.  I think there are a significant number of areas where it’s a steaming pile of dung, but the value MOSS can bring to a business is amazing.  I need to get out of the narrow arena where I’ve been and focus on the larger picture of MOSS.  Goal: deliver three successful MOSS projects or proofs of concept in the next six months, plus participate in at least one Architectural Design Session (ADS).

Improve My Community

My DevGroup.  The next Code Camp.  CodeMash.  I want our Dayton .NET Group to grow by 20% by Christmas.  I want the next Code Camp to have 150 folks attend.  I want CodeMash to have 350 attendees and mention in at least two national trade magazines who are weeping inconsolably because they were incredible ass hats and didn’t show up to cover what is going to be an amazing event.

Clean Out My Mental Cruft

I need to clean out some mental cruft that’s blocking me from clearly focusing on tasks at work.  Goal: Lose another 20 pounds within six weeks and run three times a week during that same period.  Goal: Get the trailer out and take the family on at least two camping trips in the fall.  Goal: Spend one evening a week playing alone with my daughter who’s had a rough time transititioning from me as the caregiver to my wife.  She’s the joy of my life and I need to spend more time remembering that instead of fearing her as a teenager because she’s enough PITA as a seven year old.

—————

That’s it for my list.

Five folks to tag either for career goals or the meme’s original topic of becoming a better developer:

1. Ben Carey (Because he’s wicked smart, passionate, and incredibly innovative — so I’ll steal his ideas.)
2. James Avery (Because he’s off this month and should have to do some work.)
3. Justin (Because he’s a young guy who’s very passionate, very smart, and will do great things.)
4. Drew (Because he’s moving up to IIS evangelist and I’m interested to see what his goals are.)
5. Scott Guthrie (Because his career is obviously in trouble and he needs to think hard about what he’s doing.)

What Not To Use For A Domain Name (x10)

Greg Hughes has a hysterical post listing some domain names that were very poorly chosen.  For example the Italian Power Generator company whose URL is www.powergenitalia.  The other nine are equally funny. 

Seriously, what looks good in your head may not look good in a URL.  Think twice and have someone else look at it.  Don’t tell ‘em what the URL is supposed to say, just show them the text in all lowercase and wait for their reaction.

SharePoint Installation/Configuration Guides

EverythingSharePoint.com has a couple good guides detailing MOSS installation and configuration steps.  One’s for initial installation, the second covers configuration.

The guides have lots of step-by-step details and lay out some “best practices” for various aspects.  My major gripe with the guides is that they don’t reference where the best practices were developed at.  (Actually, I’ve a long rant about “best practices” anyway, but that’s a different post…)  Many line up with what I’ve read in official MS documentation, but the author ought to at least specify where the practices were drawn from.

The content’s nothing staggering to anyone who’s done a modest amount of MOSS installs and setups, nor is it overly different than what you’d find in the Office Server 2007 Administrator’s Companion  (affectionately referred to as The Big-Assed Guide to All The SharePoint Crap You’ll Need To Know.)  Despite that, the guides are a good read.

More ReSharper Goodness: Show Inheritors

The other night over a beer Justin reminded me of another great thing about ReSharper: View a class’s derived types with Ctrl-Alt-B.  That’s an awful keystroke combo, but it brings up a great display of everything that derives from your current selection:

Slick for any number of reasons, including the infamous “Now what the h3ll was that type of Exception I was looking for?” case where you can’t remember what you were looking for.

(And don’t forget Joe White’s 31 Days of ReSharper series.  It’s on R# 2.5 but is still a great thing for pointing out the many great uses of R#.)

Updates to WinDevPowerTools Site

James finally caught up with the work that I’ve not been taking care of and has gotten some nice updates to the companion site for Windows Developer Power Tools.

If you’re on the team of a tool that was selected for the book, or if you helped write for the book, then you’re welcome (and encouraged!) to add a badge to your blog or tool homepage.  We’ve got some slick badges on this page here — the folks at O’Reilly did a slick job of creating these for us.

Book Review: Regular Expression Pocket Reference

Regular Expression Pocket Reference, 2nd Ed. by Tony Stubblebine. Published by O'Reilly, ISBN 0-596-51427-1

This is a handy little guide for common regular expression odds and ends.  The intro chapter does a nice job of giving you the regex elevator speech and hits all the important fundamentals: different engines, metacharacters, and general pattern rules.  There’s also a regex “Cookbook” section; however, that bit is only two pages and the “recipes” there are so rudimentary that they’re nearly useless and would have been better left to a different book.

The remaining chapters hit regex support in major languages, Apache, shells, and Vi and Vim editors.  These sections are very well done and give you great guidance to regex implementations on that platform, plus give you guidance on the APIs you’ll need for working with regexes.  Languages covered include Perl 5.8, Java 1.5/1.6, .NET framework with examples in C#, PHP, Python, Ruby, Python and JavaScript.  The Perl Compatible Regular Expression library (PCRE) is also covered.

Each chapter is concise, well-written and hits the major things you’ll need to refresh your memory on from time to time.

Overall it’s a very well done book.

Open Source At Microsoft

Yes indeed, it does happen.  Sara Ford posts about her team’s experiences moving their Power Toys over to CodePlex.  It makes for good reading, and it enforces the fact that there are some smart folks at MS who are passionate about getting good software out for all to use, adapt, and contribute to.

John D’Addamio, the tester on Sara’s team, has a couple good blog posts on the topic as well here and here.

Check out these pictures of her office window if for some reason you think she’s not passionate about MS embracing open source.

(And yes, I’m starting to pester her already about speaking at CodeMash!)

Working With The WebBrowser Control in WinForms

The WebBrowser control is a handy widget because you can use it to display complex content rendered in HTML in your Windows Forms applications.  The WebBrowser control, like a number of other things in .NET, is simply a wrapper around a COM control.  Additional features can be pulled from that underlying COM control by writing your own feature wrappers; however, I was able to get my required functionality straight from the .NET wrapper.

Documentation’s not all that clear on the WebBrowser, and a lot of examples actually are written for the simplistic navigation model where you’re merely programatically pointing at existing web-based URLs or files on a filesystem.  Things get a little trickier when you need to work with streamed content of any form, which is of course what I’ve been doing…

The WebBrowser holds content to render in an System.Windows.Forms.HtmlDocument object.  If you’re navigating to web or file-based content then the control manages the lifecycle of that object for you.  Life is easy.  If you’re working with some sort of stream or text data that you want to load directly into the HtmlDocument, then you’ll need to first have the control load up an empty HtmlDocument for you.  You’ll then make use of the HtmlDocument’s Text, InnerXml, or OuterXml properties to load that content.  The code below walks through this sort of case.

NOTE:  The following snippets are transmorgified from my exisiting solution and aren’t necessarily complete or compilable.  For clarity’s sake the snippets are also fuglyware, meaning there’s no error checking or good design principles.  Do the right thing and make your own code smell-free.

First, create the control:

WebBrowser browser = new WebBrowser();

Now navigate off to the “about:blank” URL which will cause a new, empty HtmlDocument to get loaded in the browser:

browser.Navigate("about:blank");

Document loading in the WebBrowser is asynchronous.  You’ll need to wait around for that document to complete its loading before you proceed on.  There are a couple different ways you can handle that.  The WebBrowser.StatusText will give you clues about the Document’s status; however, the preferred way is to handle the DocumentComplete handler.  I use a simple boolean flag and wait on it being toggled by the handler:

private bool canProceedWithNextDocLoad = false;

 

private void contentPane_DocumentCompleted(object sender,

                                           WebBrowserDocumentCompletedEventArgs e)

{

    canProceedWithNextDocLoad = true;

}

A helper method is used to wait for the document to load:

private void WaitOnDocumentLoad()

{

    //canProceedWithNextDocLoad is set true in DocumentCompleted

    while (! canProceedWithNextDocLoad)

    {

        Application.DoEvents();

    }

    canProceedWithNextDocLoad = false;

}

Actual navigation flows like this: get some content from your data source, load the content into the Text/InnerXml/OuterXml property, and immediately wait for the document to finish loading.  Those steps together looks something akin to this:

string htmlContent = ContentAgent.GetContent("someTargetToGetContentFor"");

browser.DocumentText = htmlContent;

WaitOnDocumentLoad();

The ContentAgent.GetContent call is simply how we’re handling our data access.  The real working parts are actually more complicated because I’m getting XML content from the database and running it through an XML Transform using DocBook stylesheets.  I’ve blogged elsewhere about that, so I just simplified some stuff here for clarity’s sake.

I’m working straight with the DocumentText string property.  You can also make use of the InnerXml or OuterXml and alter parts of the HtmlDocument’s Document Object Model directly.  It was easier for me to just deal directly with the entire contents.

There’s a lot of other complexity to be considered here, and there are a number of other features you can tack on.  Navigation in this manner loses the history list, so you’ll need to implement something yourself if you want to track history.  I use a simple queue to handle that.  Another thing is that all the regular navigation buttons such as forward, backward, stop, refresh, and home aren’t available, so you’ll need to work out the details on those bits of functionality — but it’s not difficult once you’ve got the basic navigation moves down.

So there you have it.  Jim’s version of Cliff Notes on the WebBrowser control.

Telerik's Controls on MOSS

Telerik has a great whitepaper laying out how to use their r.a.d. controls in SharePoint 2007.  It’s one of the better whitepapers I’ve seen and covers everything from where various files go to creating manifest.xml files and wrapping up deployment packages via WSP file creation in build scripts.  (I wish they would have taken the next step and showed using build targets to actually deploy onto the server with stsadm, but this is minor quibbling.)

I used Telerik’s radTreeView in a project earlier this year and loved its quick flexibility.  Third party contols sometimes bloat pagesize, but I think that project saw an increase of 125K or so, which for our implementation was just fine.

Check out the whitepaper even if you’re not looking to use Telerik’s controls.  There’s a lot of good info therein on general SharePoint development.

MOSS Contact Details Web Part Image Issues

Problem: Updating a SharePoint page’s contact information for a page hosting the Contact Details web part causes an error when saving the page’s settings.  The error page details are simply “An unexpected error has occurred.”

Cause: You can include a photo of the contact in the details.  The Contact Details web part creates a thumbnail of the image that’s 140x140.  The web part barfs all over itself if the target image is smaller than 140x140 and isn’t smart enough to just use the original image.

Fix:  Use an image that’s at least 140x140.

Rant: I become more and more amazed at the awful error reporting in SharePoint.  I’ve been working around various corners of SharePoint for six or eight months now and I am continually blocked by the incredibly crappy error messages.  It’s completely beyond pathetic, to the point of me wanting to deliver a couple truckloads of fresh manure to the SharePoint team’s building.  The only way to find out the cause of this particular error is to troll the MOSS logs — which site and content owners will probably not have access to. 

Do yourself and your users a favor: send out appropriate information about errors.

Rant off.

Another Handy SharePoint Blog

I just ran across Mark Arend’s blog on MSDN today.  The content there seems to be just at the right level of detail and covers a broad range of topics from development to administration to tools.

Good one to add to your reader if you’re working in the MOSS space.

Brevity Rocks

So I can get as long-winded as the next guy, but generally I’ve great appreciation for concise, focused communication, particularly in e-mail.

With that in mind, how about this great idea?  Five sentance e-mails.  It’s the right thing to do.

(Via Ben Carey’s always insightful blog.)

Should MS Buy Up Security Exploits?

Slashdot is 99% crap, but on occasion there’s an interesting post.  This article from today points out the black market where exploits are auctioned off and posits that Microsoft ought to buy up those exploits.

I think that’s an interesting premise, and the poster brings up some of the interesting complexities surrounding the idea. 

Regardless of where Microsoft is now with security, the idea is an intriguing one and might at least help patch up Microsoft’s perception as a company that doesn’t care about security.  (A perception I vehemently disagree with, BTW.)

Recipe Blogging: Two Zucchini Recipes

It's been a very, very long time since I've posted up any recipes here -- perhaps even before I started working on the book.  I'm finally back to enjoying cooking after the long haul of the book and starting a couple new jobs, so I'm in the mood to plop up a few recipes from time to time.  Fear not, I’ll keep the majority of the posts here technical.

The following two recipes are centered around some of the great bounty we get from the Communtiy Supported Agriculture program we subscribe to.  Local farmers sell fresh produce directly to consumers, which means we can get some great fruits and vegetables from farmers in the region.  It works out quite nicely, and we've been really pleased with the selection we've been getting.

Without further ado, two recipes for making tasty zucchini.

Zucchini and Kohlrabi with Parmesan and Sage

This recipe's all about simplicity, so make sure to focus on the freshness of the ingredients.  Also, look up some real Italian parmesan and avoid the faux-Parmesan stuff made in Wisconsin.  If you're using that stuff in a green can then do yourself a favor and go find some real Parmesan.  You'll throw out that green can in a hurry.  Good quality sea salt also helps bring out the best in the dish.

* 2 - 4 cups extra virgin olive oil
* 1 medium-sized zucchini
* 1 medium kohlrabi
* 6 - 8 large sage leaves
Parmesan cheese
sea salt

Place a heavy, tall sauce pan or frier over a burner.  Fill it to a depth of two or three inches with olive oil.  To avoid the oil bubbling over when frying, the pan/pot shouldn't be any fuller than 1/3 of its height.  Turn the burner on medium high.  Continue with preparation while the oil's heating up.

Slice the zuke into quarters lengthwise -- think pickle spears.  Cut the spears into 1/4" wedges.  Shoot for consistency in thickness to help the pieces cook evenly.

Peel the kohlrabi and slice in half vertically.  Tip each half on the flat side, then slice into 1/4" thick pieces.  Cut those pieces into 1/4" wide spears, then cut those spears into 1/4" pieces, leaving you a metric passle of 1/4" cubes.

Check the temperature of the oil if you've a deep frying or candy thermometer.  350F - 390F is about right.  If you don't have a thermometer then carefully drop in a piece of zuke or kohlrabi.  THe oil should bubble around quite nicely.

Deep fry the zucchini in small batches, carefully lowering the pieces into the oil with a slotted spoon or frying spider.  Stir them around a bit and cook for three to five minutes until the pieces are, as the TV chefs would say, "GBD", or "Golden, Brown, and Delicious."  Transfer to a bowl lined with paper towels and season each batch lightly with sea salt.  Add a layer of paper towels after a few batches to help drain off excess oil.

Fry the kohlrabi pieces in the same fashion, transferring to paper towels and seasoning each batch.

Finally, carefully plop the sage leaves in the oil and fry them for a moment or two until they're crisp.  They'll lose a bit of their color and will slightly shrivel up.

For final assembly, pull out a pretty bowl and carefully pour in the fried kohlrabi and zucchini pieces.  Dust with freshly grated Parmesan cheese, then place the sage leaves over the top.

Enjoy!

Zucchini with Honey

As with the previous recipe, this is all about simplicity and the quality of the ingredients.  Get some good-quality honey from a local producer or the gourmet section of a store.  Zingermans has a fantastic selection of honey from around the world if you're looking for something exotic.

* 1 large or 2 medium zucchini, quartered and sliced into 1/4" wedges
* 2 tsp. wild honey

Heat a bit of olive oil in a sautee pan over medium-high heat.  Toss in the zuke wedges and season with sea salt and freshly ground pepper.  Sautee for 2 - 3 minutes until they start to caramelize just a bit.  Swirl in the honey and continue to cook for another minute or two.  By this time, depending on the heat of your pan, the zuke should be slightly browned, just tender in texture, and nicely coated with the honey. 

Pour into a serving bowl.  Deglaze the pan with a tablespoon or two of water and pour those drippings over the zuke in the bowl.  Serve immediately.

Useful (or Not So) Error Messages

Error messages always take a bit of thought to get right.  You need to have the right amount of detail in them, and that level of detail’s different depending on where the message is going. 

Depending on the verbosity level you’re wanting, error messages to logs should have timestamp info, call stack traces, etc., and of course information specific about the error condition itself such as actual vice expected states or data.  You’ll need that level of detail when you’re trying to troubleshoot the condition.

Error message to users shouldn’t include any of that information because it will overwhelm the user and possibly expose too much info about your system, thereby creating a security risk.  That said, you do need to tell the user some useful information — unlike the error message I’m staring at from GMail’s signup screen where I’m trying to enter my initial information.  I’ve put in a couple different passwords and am rewarded with a red bit of text which merely says “The password you gave is incorrect.”

OK, so I’m not a rocket scientist, but this is not particularly helpful.  The password doesn’t meet their minimum standards and they aren’t nice enough to tell me what those standards are.  Is the password too short?  Does it contain illegal characters?  Does it not contain required characters?  What are the required types of characters, and how many do I need?

Do yourself and your users a favor.  Don’t leave them hanging with vague error messages.  Put a little thought into the messages you’re creating when something’s gone south.

Why PDB Files' Version Matters

Jim Gries, absent too long from his blog at Gooey Bugs, puts up a nice post with some insight as to why you need the PDB files from the exact build you created your binaries with in order to use the debugger.

You ought to think hard about building PDBs even for your release versions and archiving those with the released binaries.

Check out Jim’s past posts, including his series on Debugger Tips, Tricks, and Tools.  It’s been a long time since I read through those, and I’m finding a lot of useful stuff there.

Book Review: The Art & Science of CSS

The Art & Science of CSS, Cameron Adams, et. al.  Published by sitepoint, ISBN 0–9758419–7–1

This is really another amazing book from sitepoint which has been putting out a great line of web design/standards/crafting books.  I loved The Principles of Beautiful Web Design (review here) and James has spoken very highly of HTML Utopia: Designing Without Tables Using CSS.  This book seems to follow right along the same bent: concise, well-written content at exactly the right level of detail to convey the point the authors are working on at the moment.

Art & Science won’t teach you the fundamentals of flow, divs, spans, or even CSS basics like classes and IDs; however, the progress through the book is so well-paced and clear that you’ll be able to fill in any gaps in your knowledge as you read along.

The book has seven chapters, each on a specific aspect of CSS such as Headings, Images, or Navigation.  The chapters lay out basic premises of the topic, such as how you want to think about your headings as part of a page/site’s branding and impact, then move on to details of creating and implementing a beautiful design.  Each chapter makes its points in small, incremental steps such as starting off with basic vertical navigation, progressing to more advanced horizontal such as navigation with hover/current location changes, then finishes up with advanced concepts like matrixing menu images so you can show complex combinations simply by dealing with positioning.

All of this is accomplished in a style and depth of content that’s applicable to folks with rudimentary design/CSS skills (i.e. yours truely) as well as accomplished web designers.  What really amazes me is that the authors hit such a broad audience (and did it well!), covered a broad range of topics in detail, and pulled it all off in just over 200 pages.  (And those pages, by the way, are glorious full color.)

This is a great book for learning how to deal with CSS in an elegant, well-architected fashion.  It’s simply a terrific book if you’re doing anything at all with CSS.

Now Playing: Mike Farris — Salvation in Lights.  Holy smokes, this is some amazing stuff.  Farris used to front for Double Trouble for a bit and this album’s right along that style, except that it’s Americana/Gospel.  Farris has an amazing, HUGE voice and the band behind him tosses out great tunes to back him up.

Blogroll Slightly Updated

I’ve done a bit of pruning on my blogroll (right sidebar, if you please), and I’ve also added in links to all my colleagues at Quick Solutions who have blogs that I know of.  I figure I’ve just gone over a couple months at QSI and they’ve not thrown me out of the door (yet), so it’s safe for me to link to some of the Really Smart folks I work with.

By the way, Quick is always looking for good folks in a wide range of disciplines.  Please drop me a line (contact link on sidebar) if you’re looking for work in the DBA, .NET, Java, business analyst, or program manager fields.  We’ve got plenty of positions for people who are interested in finding a terrific place to work.  Are you interested but worried your skills might not fall right in one of those slots?  Drop me a line all the same — we’re open to helping good folks grow their skills.  It’s a long-term thing <gasp!>.

Book Review: Pro .NET 2.0 XML

Pro .NET 2.0 XML by Bipin Joshi. Published by Apress, ISBN 1-59059-835-3

This book has a number of flaws, but it's still a useful book for learning about using XML in the .NET world.

First off, the flaws: it’s rather shallow and leaves out details or concerns on a number of topics.  Examples include skimming over a DataSet’s ability to infer a schema when reading data in.  Are there any drawbacks?  When would you use this?  When might you want to avoid it?  Secondly, the voice is a litttle clunky at times and there are some annoying typos/grammar issues; some better editing would have helped the author out a lot.  Additionally, I found it frustrating that a lot of the text is little more than a walk through of the code examples, lending little insight about the concepts.  I found myself thinking to the tenet behind good code documentation: tell me the why, not the what. 

Lastly, and this is an annoyance I’ve noticed in a number of books: default names are blithely accepted for controls, leaving the book littered with code examples like

private void button2_CLick(object sender, EventArgs e)

{
comboBox1.Text = ...
textBox1.Text = ...
textBox2.Text = ... 
}

I find this incredibly annoying since there’s no connection whatsoever to the example graphic.  It’s bad in code, and it’s bad in a book.

So with the bad news out of the way, let me focus on the positives, because they’re definitely there.  There’s a lot of content on a broad range of topics.  There’s a very solid introduction to XML which is soundly and concisely written.  The discussion of SAX and DOM is nicely done, and there are a large number of fundamentals which are well-written. 

You’ll be able to learn the basics on things like XML’s use of DTDs, how schemas roll into things, the basics of validation, and a number of other topics.  The chapter on XML in ADO.NET has some good coverage on XML support in DataSets, and there are solid chapters on Web Services, SQL Server support, and a chapter which combines remoting, XML in ASP.NET, and configuration files.  Joshi also wraps in a chapter on XML’s role in WCF.

I think the book’s a solid introduction to XML in the .NET world, but I wish it hit a bit more detail and discussed possible tradeoffs or impacts of choices.

Book Review: Release It!

Release It! by Michael T. Nygard.  Pragmatic Press, ISBN 0–9787392–1–3

The subtitle of this book might as well be Architecture and Design for the Paranoiac. The book lays out some critical aspects to creating and rolling out stable software systems.  It’s directed to those working in the enterprise arena and need the utmost from stability, capacity, and overall design.  Nygard’s definition of “enterprise” is somewhat broad in that he considers “enterprise” to be any system providing mission-critical support to a business.  Regardless of how you define your particular software, I’m sure you’ll find something useful in this book.

Nygard presents the book from an anti-pattern/pattern approach: he uses case studies to illustrate how critical errors in design or implementation (anti-patterns) have caused disasterous outages.  He then moves on to show how application of solid design patterns could have avoided the problems.  He also spends some time going in to detail on how some of the outages have happened, including brief discussions on network packet captures and decompiling third party drivers.

There are a lot of solid fundamentals in the book: dealing with exceptions at system integration points, thread synchronization, avoid rolling your own primative feature libraries such as connection pools, and make sure to test third-party libraries which play critical roles.  The general approach of discussing anti-patterns followed by patterns is also a nice way of putting forth the material.

There are a lot of more complex bits covered as well, such as thinking ahead on how you’ll deal with bots and crawlers, avoiding AJAX overkill, designing ahead for and using session.  I also liked that Nygard talks about the importance of involving the customer in decisions on thresholds and other critical boundaries.

Despite the great content, there is a blistering flaw, IMO: A complete lack of solid implementation specifics.  Nygard doesn’t provide much detail at all on actual implementation of the critical patterns he espouses, nor does he point you in the direction of other sources of information.  For example, the Timeout pattern is held up as a vital aspect in many parts of the book; however, there’s no practical detail on actual code to implement a Timeout, and there’s only one reference to a practical implementation.  The Circuit Breaker pattern, central to many of Nygard’s architecture assertions, doesn’t have any code or a single reference to other material where you can find implementation details.

While I find that a major gap in the book, otherwise I think it’s a solid addition to one’s bookshelf.  The writing style’s very nice, his writing voice is light and concise, and the summary bullets in each section (“Remember This”) are of great value.  Additionally, there are plenty of references to other useful works.  (Just not for the patterns I complained about above.)