By Roy Osherove
320 pages
http://www.amazon.com/Art-Unit-Testing-Examples-NET/dp/1933988274

So, I ordered this book along with a few others when my team was about to start writing unit tests.  Of all the books I ordered, this one was the most packed with realistic, hands-on guidance on how to organize your tests, and wide-ranging best practices and test patterns for how to write tests that are easy to maintain.

Roy Osherove has a lot of experience helping companies with “the art” of unit testing.  He believes the key to successful unit testing rests on three pillars: maintainability, readability, and trustworthiness.  He explains in the book what those things actually look like in real-world examples and why you might not be getting everything you could be out of your tests if you overlook one of those.

Roy also includes a fairly detailed comparison of the latest tools and frameworks you have to choose from.  This section alone could save a ton of research time by getting a fairly unbiased, expert’s view of the pros and cons for these types of tools and frameworks:

• Test Frameworks: NUnit, MSTest, MbUnit, Gallio, xUnit, Pex
• Isolation Frameworks: Moq, Rhino Mocks, Typemock Isolator, NMock, NUnit.Mocks
• IoC Containers: StructureMap, Unity, Castle Windsor, Autofac, Common Service Locator (CSL), Spring.NET, Managed Extensibility Framework (MEF), Ninject
• Web Testing: Ivonna, VS Team System Web Test, NUnitAsp, Watir, WatiN, Selenium
• UI Testing: NUnitForms, Project White, Team System UI Tests
• Thread-Related Testing: Typemock Racer, Microsoft CHESS
• Acceptance Testing: FitNesse, StoryTeller

This book was a short 320 pages, but there is a ton of practical and applicable tips jammed between the covers.  But, I have to mention that this book isn’t as polished as you would probably expect with most published works.  It isn’t anything major, but just a few things in the text or code samples that should have been caught by testers or an editor.  These issues don’t really take away from the content, but it just wasn’t up to the standard I expect when buying a published work.  (And that is possibly the worst cover I have ever seen ... yes, I get the reference to "The Art of War").

If you are remotely interested in this topic, you should listen to a recent podcast Roy did with Scott Hanselman on “The Art of Unit Testing.”  Although the podcast is kind of like a cliff-notes version of the book … it isn’t a replacement.  If you find the podcast remotely helpful, order the book.

By Michael Feathers
456 pages
http://www.amazon.com/gp/product/0131177052

This was one of those famous, timeless books (like Code Complete) that I had heard many people talk about, and I finally read it. To be honest it was in my Amazon "Wish List" for several months before I ordered it, but it lived up to the hype.

Remember when you first started writing software? Like most people, for me it was a very exciting time and I truly enjoyed learning and trying to push the boundaries of programming. It is a very primal passion that engulfed me, and it is the reason many of us got into this industry. Where did that go? Do you still feel that today? If so, you are one of the lucky ones. In this book, Michael explains how large code bases (that don’t have tests around them) can sometimes suck that enjoyment out of our day-to-day tasks, because we slowly develop a fear making changes to this monolithic application because we are worried about what we might break or what expected side-effects fixing a bug or adding a new feature might have. Although we might not typically acknowledge this fear, it is present whether we admit it or not.

Sometimes we romanticize the idea of working on “Greenfield” projects, because if we were just able to start from scratch … this would be much easier and a lot more fun. I have slowly become convinced that isn’t the case. There is tedious and unexpected ripples in new projects just like existing projects. This book is dedicated to given practical techniques to remove that fear, and get to a place where you can actually enjoy working in your code base. It is possible, and Michael has the experience and expertise to help you bring your legacy systems under control.

I often am weary that books like this that are on “hot” topics like test-driven-development are fluff, and aren’t very relevant to my day-to-day real-world code. Not true … at least not on this book. I would highly recommend this to book to anyone. It is worth the money, time, and effort to read it cover-to-cover. This is probably in my top 5 for technology books in terms of real-world value they provide.

By Lynn Langit, Kevin S. Goff, Davide Mauri, Sahil Malik, John Welch
624 pages
http://www.amazon.com/Business-Intelligence-Solutions-Microsoft%C2%AE-PRO-Developer/dp/0735625808

I recently completed a business intelligence project at my company that included things like aggregating data from various sources into a centralized data warehouse, and then processing that so it could be accessed through both an OLAP cube and a relatively simple relationship database.  I believe the project was a complete success, and am very happy with the both the functionality we provide to our end-users (who are regular business people, and not just analysts) as well as how easy to maintain and robust the end-solution is.  I think that last part is what probably gets most companies.  They develop some type of data warehouse for business intelligence, but it is a house of cards that just continually sucks their time because it is so fragile or always needs to be updated to allow a business analyst to slice or view the data in a new way.  I can definitely see how you could end up there, and I believe this book was the primary contributor to the success of our project.

I work for a small business (currently ~65 employees), and right now our IT Team has three members: 1 system admin, 1 full-time developer, and me (my time is split half and half between software and business management).  None of us had any experience with OLAP, SQL Server Integration Services (SSIS), or SQL Server Analysis Services (SSAS) … although I had sat through a few sessions/workshops over these topics at conferences.  Although it is counter-intuitive (especially to someone who is a developer at heart), I have come to believe in the notion that the sooner you start coding the longer it will take.  So, I knew I needed to get some more in-depth expertise in these areas before we started the project, which is why I ordered this book.

Before I even created the first prototype, I forced myself to sit down away from the computer and read the first two parts of the book (~400 pages).  It it was eerie how much the content seemed custom-tailored to my current situation.  It was targeted at a more technical audience, so the detail and depth used was spot on, and it assumed you had some working knowledge of OLTP relational databases so it didn’t have to go over all the basics.

The book covers a ton of best practices that the authors have learned "the hard way" while implementing a ton of business intelligence solutions on the SQL Server framework, and most of them were not entirely obvious.  The whole business intelligence area is still in its early phases, and there are a lot of gotchas.  SQL Server 2008 has made some significant improvements over past implementations to help guide you to best practices, but there are still a lot of gotchas.  The authors also demostrate an in-depth knowlegde on the new features SQL Server 2008 offers, plus then explain when/how you might use them. 

At 624 pages, this book may seem a little overwhelming … but I think it is worth its weight in gold.  It is almost like you have an experienced consultant sitting beside you.  If you are considering implementing a business intelligence solution, there are tips in this book will save you time, effort, and you will end up with a better solution for your business in the end.

By Jenifer Tidwell
352 pages
http://www.amazon.com/Designing-Interfaces-Patterns-Effective-Interaction/dp/0596008031

This book is a pretty good overview of UI design.  The concepts could be applied to interactions with pretty much anything, but Tidwell does focus most of the time on desktop and web applications, as well as some mobile device interfaces.  The book defines around 80 different patterns that can be used to solve common design issues.  As the author points out, "This book isn't Design 101; it's more like Design 225.  ... It's expected that you already know the basics of UI design."  But as you might expect, a lot of the material is stuff you already know inherently, but there were enough concepts that were either new or were things that I understood at least at a subconscious level, but were worthwhile to formally define.

One thing that was surprising was that there was some overlap in the information from this book and another book I read recently entitled "Information Dashboard Design."  Both pointed out the human ability to process some visual features "preattentively."  This simply means there are some things our brains can derive meaning from before the viewer pays conscious attention.  If you make use of those aspects "your visual system does the hard work for you, and it seems to work in a massively parallel fashion."

There were also several concepts related to information architecture, which is closely related to a UI's design.  One especially helpful section was an extensive list of controls that typically work best to represent a particular type of data.  I plan on writing another blog post around this topic in the near future.

By Stephen Hawking
224 pages
http://www.amazon.com/Brief-History-Time-Stephen-Hawking/dp/0553380168

I graduated from Texas Tech's College of Engineering, and after taking the same physics courses that any other engineer or physics major took ... I thought I had a pretty firm grasp on modern science.  The first chapter blew away that idea.  There is a quote that I love, which goes "If you can't explain something to a six-year-old, you really don't understand it yourself."  (This is often misattributed to Einstein).  Stephen Hawking fully embodies this idea with his uncanny ability to present several complex ideas in a clear, concise manner.  In fact there are many ideas in the book that are in direct opposition to the historical physics taught in classrooms or the "common sense" ideas we assumed were correct.  Hawking can skillfully explain why some of our basic assumptions about the universe and the world as we know it are no longer valid, and does so in a unhurried, step-by-step fashion so that by the time he draws the conclusion you are still right there with him and really understand ... instead of just taking his word for it.  In fact, there were a few places where he really shook up some fundamental ideas within a single paragraph.

This book is Hawking's attempt to give an overview of the scientific advances over the past few centuries, and catch people up to the present state of science.  He specifically covers relativity and quantum mechanics, as well as other related topics like black holes, wormholes, and string theory.  This may all sound very academic, but the fact is that many of these discoveries or theories could shape our future in drastic ways ... and some already are.  Here is a good quote from the book that seems to sum up the need for this "update" on modern science:

In Newton's time it was possible for an educated person to have a grasp on the whole of human knowledge, at least in outline.  But since then, the pace of the development of science has made this impossible.  Because theories are always being changed to account for new observations, they are never properly digested or simplified so that ordinary people can understand them.  You have to be a specialist, and even then you can only hope to have a proper grasp of a small proportion of the scientific theories.  Further, the rate of progress is so rapid that what one learns at school or university is always a bit out of date.  Only a few people can keep up with the rapidly advancing frontier of knowledge, and they have to devote their whole time to it and specialize in a small area.  The rest of the population has little idea of the advances that are being made or the excitement they are generating. (p185)

Hawking actually wrote that in one of the later chapters about the "Unification of Physics" through ideas like string theory, but the idea is valid regardless of the context.  Our civilization is progressing so rapidly that we can't expect to keep up with everything.  But this book sheds light on some very fundamental ideas that could radically change how you view the universe, or at least make you question some things you once thought of as facts written in stone.  Stephen's condition (Lou Gehrig's Disease) makes it difficult to write books, so you can bet that if he took the time to include a particular sentence or concept in the book ... he feels it is pretty important.  That is why this book is barely 200 pages.  I kind of consider it the cliff-note version of the last hundred year in physics.  But then again, don't expect to fly through this book when you read it ... he will definitely through you for a couple loops, some of which may take a while to digest.

By Roger Sessions
208 pages
http://www.amazon.com/Architectures-Enterprises-PRO-best-Practices-Microsoft/dp/0735625786

I saw this book on the shelf in the Microsoft store at TechEd 2008 a couple weeks ago, and when I read the title I seriously laughed out loud.  I thought, "Finally ... the answer to all my problems, and they were able to fit it in just over 200 pages.  Amazing!"  I didn't even pick it up.  But, during the 2nd week of TechEd I was hanging around wasting time between sessions and curiosity got the best of me.  I wanted to know just what kind of b.s. could possibly be between those covers.  Within 5 minutes I bought the book, and after I started reading it I actually ordered another copy off Amazon and had it overnighted to a developer I work with so he could read it too.  Every now and then I read a book, and go "holy crap, this is really useful stuff" ... and this is one of those books (Code Complete, and Don't Make Me Think are others).

Roger Sessions outlines why the top issues CIOs claimed they faced in a December 2007 article in CIO Magazine (e.g. improving IT planning processes, improving project management capabilities, reducing IT costs) weren't actually problems ... they were side-effects of a fundamental problem of the high complexity inside most organizations.  Most enterprise architectures are extremely time consuming and expensive (not to mention critical because are the foundation of an organization's entire technology infrastructure).  But Sessions exposes the truth that most enterprise architecture decisions today are based on instinct, gut feeling, politics, vendor loyalty, and so on, and because of this the only way to know if an particular architecture is good or bad ... is implementing it (a very big gamble).

Sessions looks also looks at many of the popular enterprise architectures used today, and doesn't seek to replace them with some revolutionary idea, but instead he tries to compliment them with some additional methodologies he called SIP (Simple Iterative Partitions) which gives a special focus to the root cause of so many IT project failures ... complexity.  He doesn't just present his opinion on how enterprise architectures should be done, but instead performs thorough, scientific, mathematics-based investigation on how to make an architecture as simple and modular as possible.  In the end he provides some practical steps on how to integrate this thinking into your current infrastructure.  Like so many new trends, he doesn't expect you to (as Scott Hanselman jokes) open a new window, and go to "File > New Company" ... but suggests a realistic, iterative approach for how to work this in as a fundamental philosophy of your systems without shutting down the IT team for a couple months to work this stuff in.

Seriously, this is probably the most useful book I have read so far this year.  I am going to take its message to heart, put it to work immediately, and I know my business will experience more value, flexibility, and stability because of it.

By Judith Bishop
314 Pages
http://www.amazon.com/3-0-Design-Patterns-Judith-Bishop/dp/059652773X

This book is a collection of 23 common software design patterns with examples in C#.  However, even though the cover says C# 3.0, the author blurs the lines a little and refers to some functionailty that wasn't available in the .NET Framework until v3.5 ... which is OK, because the main point of the book is to convey the different design patterns and when you might think about using each, but it was a little confusing.

The author groups patterns with similar uses and then steps through each one, including:

• Brief description of the pattern's role
• UML diagram of how the different parts involved in the pattern fit together
• Simple code example (focused on fundamental design and implementation)
• More complex "real-world" example of how it might be used
• Discussion of when it might be used or alternative patterns to consider
• Additional excersises to help you better understand the pattern

Overall, the book seemed pretty useful.  Some of the patterns covered in the book are probably rarely used in the real world, but others are design patterns that we use as software developers pretty constantly without realizing it.  Getting a formal definition of what those are, and all the different parts involved ... as well as when it is a good idea to use it or what other pattern might be a better fit really offers some value.  It was a pretty short book, so I thought it was worth the investment of time to read it.

By Stephen Few
223 Pages
http://www.amazon.com/Information-Dashboard-Design-Effective-Communication/dp/0596100167

This book is really useful.  I picked this up one evening on a regular visit to Barnes and Noble, just because I had seen one of the really talented analysts I worked with reading it.  I started thumbing through it, and was amazed by the meat packed in between the covers.  The term "dashboard" has become a huge buzzword as of late, and seems to be what everybody from line workers to upper executives want ... even though most don't have a clue what it is or what this magical tool would even look like.

Stephen cuts to the heart of this confusion, and gives some practical advice for how to effectively use dashboards in your organization.  Since so many people have varying ideas of what a dashboard is or should be, Stephen starts by looking at what some sources say a dashboard is and combines some of those into what he thinks the best defiinition is:

Dashboard - Visual display of the most important information needed to achieve one or more objectives which fits entirely on a single computer screen so it can be monitored at a glance.

He is very intentional in the exact wording of that definition, and goes into greater detail about why each word or phrase is important and how it ties into the primary goal of the dashboard.  He shows numerous examples of some dashboards currently available from companies like Oracle, Informatica, Cognos, etc. and points out the strengths and weaknesses of each.

The thing I liked the best about this book is the scientific approach to our visual perception.  Stephen presents some concepts that we seem to understand subconsciencely ... but brings them into the light, and explains how we can make better at-a-glance dashboards by making use of things like hue, intensity, 2-D location, orientation, line length, line width, size, shape, added marks, encloser, and the dreaded flicker.  He also explains why/how to tone down the "noise" (and often times the flashiness) of the dashboard so that it can better serve its purpose.

I consider this a must-read for any analyst or developer who designs dashboards for their organization, or tries to represent data visually in any form or fashion.  If you read it and apply the concepts it covers, I really think it could add some serious business value.

By Scott Klein
408 pages
http://www.amazon.com/gp/product/0470041811/

Many technical books are designed to be reference material (i.e. the only time you open it is to flip to the index in the back and read a short section to help you debug a very specific issue).  Those have their place, but when something as new and powerful as LINQ comes out ... I want to get a book that is a good cover to cover read, and dives into fundamentals, best practices, and even advanced scenarios.  This was that type of book.  I still use it as a reference from time to time, but after reading it through, I instantly felt more comfortable with LINQ and understood how to leverage it in ways that I might have missed otherwise.

One random tip ... LINQ to XML is not as great as they make it out to be.  Although LINQ to objects/collections and LINQ to SQL is crazy powerful, terse, and a more natural and productive way to help with an array of common programming tasks, I have also had some experience with LINQ to XML ... and I can't say the same thing for it.  The author covers all of these LINQ-related topics, so you will probably see what I mean ... but I just wanted to mention it.

Overall, this was well written, had concise, real-world code examples, and was a great cover-to-cover read.  I would recommend it to anyone.

By Jerri Ledford & Mary Tyler
336 Pages
http://www.amazon.com/Google-Analytics-2-0-Jerri-Ledford/dp/047017501X

Google Analytics is a tool you can use to understand how visitors behave when they visit your web site.  It goes well beyond other "web stats" software, and the book even points out the benefits and drawbacks of using Google Analytics versus a popular web stats program named AWStats.  Google purchased a web analytics firm named Urchin in late 2005, re-branded the product Google Analytics v1.0, and began offering the service free of charge.  The response was overwhelming, with a 1/4 million new accounts overnight.  It seems Google had under-estimated the market and had to turn people away while they began to redesign the system to be more scalable and more usable for the average webmaster or mildly technical business person.  Out of this, Google Analytics v2.0 was born.

There is a ton of out-of-the-box functionality built into Google Analytics, but if a user never goes beyond that they will miss out on some of the biggest benefits that can be found in features like goals, and custom filters.  These features can be used to track the success of your web site, your marketing efforts, and your products and services ... which could be important.  This book presents these fairly complex concepts in plain language that anyone who is fairly technical can understand.

The book also explains how to setup profiles and other users so that multiple people in an organization can have access to the reports.  This is pretty easy to do, but again the book explains it in such a way that almost anyone can understand the importance of assigning users to a particular profile and the differences in roles (i.e. reports only or account administrator).

It also walks you through each report section of Google Analytics, and gives you an overview of what each report is displaying, it's drill-down capabilities, and any assumptions or "gotchas" that might exist to help you understand the data behind the report.  It also points out a few real-world business uses of a few of the reports, and how you can leverage a particular report to make business or design decisions ... which also could be important.

Overall, I think this is an essential manual for anyone who wants to get the most out of Google Analytics.  Like I said, the software really has a lot of power and functionality out-of-the-box, but if you can go beyond that into some of the more custom features you will get a lot more value out of it ... and this book helps you get there.  Its an easy, light read and most people can probably read it in just a few sittings.  I would recommend it to anyone in your organization that is going to ever log into Google Analytics.

By Paul Allen
360 Pages
http://www.amazon.com/Service-Orientation-Winning-Strategies-Practices/dp/0521843367

So SOA (Service Oriented Architecture) seems to be a pretty hot topic these days ... and for good reason.  However, this isn't something that is brand new.  For example, recently my company began looking for a replacement for our accounting software, and some of our other "custom" applications need to be able to interact with that system.  The reason we were looking to replace our current software was not just because it was buggy (in my opinion it should still be in beta), but also because the software didn't have any built-in way to interoperate with outside applications.  So since we had a need to interact with data that system maintained, we managed to do that by getting down to the ODBC level of their database.  The problem with this is when the company did implement a bug fix or upgrade versions, it was a disaster because it would often break some of our pieces that were tightly-coupled to their data structure.

So one of the top features I was looking for in a new accounting package was the ability to interact with the system through something like web services, instead of getting down to the lower level connections and having to know all the little intricacies of their database schema and remember to populated all the right data when one of our applications needed to insert, update or delete some information.  I wanted something higher-level that would abstract all that stuff, and let me focus on other things.  We eventually settled on Microsoft Dynamics GP, which provides a web service layer who's interface will persist through version upgrades.  This means although Microsoft may totally restructure how the data is stored at the database level or how the Dynamics GP application works or behaves, they will account for these changes in the web service logic so all of the exposed methods still work as expected ... which also means all of the code we write to interact with these web services will continue to work without any issues (at least in theory).  Turns out this type of "architecture" has a name ... SOA.  OK, I did read the book and I know SOA is more than web services, but right now most SOA implementations use web services so this isn't too much of an over-simplification.

SOA is really just a way of separating different applications or layers of functionality so that they can be loosely-coupled.  This allows them to adapt to change more easily, or even replaced completely if needed.  It also allows developers to easily reuse some code or functionality across multiple applications or channels (e.g. desktop, mobile, kiosk) and still only have to maintain that code in one place.

The way I sometimes think of SOA is similar to a class.  As defined in Code Complete, "a class is a collection of data and routines that share a cohesive, well-defined responsibility ... A key to being an effective programmer is maximizing the portion of a program that you can safely ignore while working on any one section of code."  A class is used to encapsulate some piece of functionality and hide the implementation details.  It only exposes the data or methods that are necessary and nothing more.  SOA is really similar to this concept, except on a larger scale.  A service might include several or even hundreds of classes that are closely related, but really it is just another way to group some type of functionality and hide the implementation details.  This is probably an over-simplification, but I think it illustrates the core concept of SOA.

As far as this particular book goes, I think it was alright.  It seemed more academic than practical.  It felt like some of the college textbooks I was forced to read where the author was an expert on the concepts and principles they were talking about, but weren't very relevant to industry.  Its like they had worked in research and academics for so long they lost touch with what was going on in the real world, and spent too much time on topics that the every-day developer/architect didn't need to know.  Although this book was published by Cambridge University Press, it wasn't written by professor.  It was written by Paul Allen, who according to the about the author section "is the principal business-IT strategist at CA."  That probably means he knows something about industry, but I just wasn't the target demographic for this particular book.  Don't get me wrong ... it wasn't a total waste of time, but 1/2 of it could have been edited out and I still would have walked away with the same applicable knowledge.

.netTiers is the object relational mapping software that we currently use for all our applications.  In my experience it is extremely flexible, and saves me the several hours a week I used to spend writing custom CRUD (Create, Read, Update, Delete) methods to various objects in the database.  Plus since it is open-source and template-based, I can go in and change any part of it I see necessary. 

There are a lot of places on the Internet that list what the .netTiers templates provide, but I couldn’t really find anywhere that provided a clear, comprehensive overview of what it provided … without going into too much detail.  So I pieced together the following definition that explains what .netTiers is and the functionality it could provide.  .netTiers really does save me and my team hours of development time every week, so if it sounds like something that might help you out … you should definitely check into it further by going to www.netTiers.com.

.netTiers is a set of free CodeSmith templates that targets an existing datasource and automatically generates a personalized architecture to use in your .NET applications.  The generated code is custom to your domain, uses familiar patterns, and follows the guidance of Microsoft's recommended patterns and practices.  In fact, the .netTiers base architecture is built upon the Microsoft Enterprise Library Application Blocks.  Core features include:

• Generate strongly-typed business entities with a 1:1 mapping to the datasource (an entity for each table or view, with a property for each column):
  • All objects are serializable, and support trigger events
  • Implements an IEntity interface, which contains the columns that are present in every table
  • Each object has a concrete and a base class which it inherit from. The concrete class is generated just once, so after the first time you can then add your custom logic straight in the code-gened files
  • Uses a custom generic List for collections that are sortable, filterable, and directly bindable to datagrid and other ASP.NET and WinForm controls
• Generate Data Access Layer Components (DALC) for tables and views, with following database operations:
  • Support for basic CRUD methods, plus several other useful methods such as Select All, Paged Select, Find (with paging and sorting), etc and allows the addition of your own custom methods
  • Support for queries using primary & foreign keys, as well as keys that are part of an index or junction table
  • Support for Deep loading and saving, with children type selection and optional recursivity
• Option to use stored procedure or parameterized SQL inside the application
• Generates a complete nAnt build file, to compile, test and generate documentation
• Generates a full set of nUnit tests
• All code is fully nDoc commented and follow the Microsoft naming guidelines
• Open-source so you can modify the templates if necessary

Back in March I attended DevConnections in Orlando, and sat in one of Rob Howard's sessions on CodeSmith.  I have always had a pretty negative outlook on "code generators", because most tools don't give you enough control over what code is actually created.  I take a lot of pride in writing applications that are extremely scalable, and frankly some of the code that is generated is not as efficient or isn't as optimized for my particular application and environment as I would like.  So before I even sat down in that session, Rob already had an uphill battle to fight.

However, the tool that Rob showed us was quite different than any other code generator I had ever seen.  Simply put, CodeSmith is a template-based code generator that is commonly used to generate ORM-type architectures based on your database and settings.  The key phrase in that sentence is template-based.  There are a ton of templates available that are provided by a community and open source.  This means that you can download one of the proven architectures like .netTiers, CSLA, NHibernate, Wilson's ORMapper, or others and if something isn't coded, commented, or formatted exactly how you would like it ... you have the full ability to modify the template to your liking.  This means you don't have to write the entire architecture, but have control to change any line of generated code if you need to.  In my experience since using the product, you really don't have to mess with them too much, but it really gives me piece of mind to know that I could change the behavior instead of just having to live with whatever code the black-box generator spits out.

It is kind of hard to conceptualize what all CodeSmith has the ability to do.  It can generate C# and VB.NET code, but can also generate anything else: T-SQL, JavaScript, XML, RTF, or a language you just made up.  This was hard for me to grasp at first, but CodeSmith Studio (the IDE used to create/view/edit templates) looks and feels a look like Visual Studio.  But instead of writing code in Visual Studio that at the end of the day will become a software applications, you write code in CodeSmith Studio in a way that feels extremely similar to .NET and when you compile and run the code the output is generated code, XML, T-SQL scripts, or could even be documentation.  So it is kind of open-ended as to what you can actually use the tool to generate.  I will try to post some examples on the site sometime soon that demonstrates some of the significantly different types of things you can generate.

Bottom line of CodeSmith: This software is one of the most useful development tools I've seen.  In fact, I see CodeSmith and the RedGate Tools as must-buys for serious developers, and are almost on the same plain as Visual Studio itself.  Both of those tools are extremely reasonably priced, and the time saved developing and maintaining an app far outweigh their cost.  At the time this was written, CodeSmith Standard was $99/license, and CodeSmith Professional was $399.  For more info go to CodeSmithTools.com.

By Alexandru Serban
404 Pages
http://www.amazon.com/SourceSafe-Software-Configuration-Management-Practice/dp/1904811698/

Publisher’s Description: This book uses a real-world case-study project to teach you how to manage software configuration efficiently using Visual SourceSafe 2005, Microsoft's Software Configuration Management (SCM) solution for independent developers and for developers working in small- and medium-sized teams. It also provides a best-practices reference on using SourceSafe 2005 to manage the software development lifecycle.

My Thoughts: Why aren’t there more books on SourceSafe?  Moreover, why is SourceSafe so anti-intuitive?  I realize it has seamless integration with Visual Studio, but actually setting up projects in it is a painful process, and forking code and merging branches isn’t that easy either. 

This book does explain how to do these things, but it isn’t written very well.  There are a ton of screenshots that let you easily follow the author through some examples, but a lot of them could have been excluded.  With a good editor, this book could be trimmed down to about 100 pages of real meat.  The author goes into too much detail about the 43 different ways to do something, when really they are all extremely similar or he is going to introduce the way you should really do it at the last of the chapter.

One crucial topic the book left out was how to add stored procedures to SourceSafe.  That is one of the most attractive things about it, and it was left out completely.

But, there isn’t a better book out there that I know about … so what can you do?  It is better than the built-in help in SourceSafe, so it was probably worth the money for me and earned a spot on the bookshelf.  But it wouldn’t take much for someone to through together a better book, not to mention better software.

In fall 2006 we were looking for a way to equip our inspectors with an always on “high-speed” internet connection in the field.  We were planning on getting them setup on ruggedized tablets, so they could complete checklists about various construction tasks that were customized for each home.  This would be used to not only track the progress of homes, but fully automate the production process.  When one checklist was finished for a home, a checklist for the next construction task would be created and would show up on another inspector’s tablet.  We would also be able to tie email notifications to give our trade partners a heads up when it was almost time for them to be involved with a home, and use them to allow inspectors to approve payment for materials and labor out in the field.  So with all this, we really put a lot of effort trying to make it work.

During this time in Lubbock, the data service available from cell phone companies was extremely slow (around 56Kbps), which would was too slow for what we were hoping to do.  At first we were thinking about writing an application that could run online or offline, and when it came into a hot spot it would sync up with the live database.  The inspectors are away from the office all day, so we thought about creating a mesh wireless G network that completely covered some of our larger communities.  This turned out to be pretty expensive for outdoor equipment, and seriously sounded pretty hinky.  So when someone told us about a new company named Xanadoo that might be able to help us out, we were all about it.

I called Xanadoo, and they sent one of their top people in the area (I think he was also a stakeholder in the company) to the office to talk with me.  I explained what we were trying to do, pointed out the locations of our major communities, and they assured me they would be able to provide us with the service we were looking for.  They said their service should be able to provide our guys with a connection anywhere in Lubbock County, which seems more than adequate.  They could provide small wireless modems that received a signal from unidirectional antennas around town.  In fact, they were so confident they wanted to sale me a few of their modems right then.  I told them I would like to get a complementary modem to test with first, and it took them a couple weeks to get one to me. 

Since they were so confident this would work, I moved forward with developing this solution.  When I finally got the modem, our system admin and I hooked it up to a laptop and decided to drive around town and see what kind of connection we could get.  Needless to say we were a little surprised.  I had got them to point out a few places locations of their unidirectional antennas, and we drove near one and were able to get a connection.  However, if we were ½ a mile or more away from the tower (or directly below it) the connection was either unreliable or non-existent.  Their service didn’t even get close to covering the city of Lubbock, much less Lubbock County.  We thought we might have had a faulty unit or be trying to use it incorrectly, so we went to their offices on 82nd St and talked to an employee.  We told them we were having some trouble getting a signal, and we couldn’t even get one in their parking lot.  They acted surprised, and said of course we weren’t getting a signal there … there is never a signal out there.  What?

It turned out we were doing everything right, and their service simply didn’t match up with what they claimed.  We tried a few external antennas, but eventually abandoned the idea after we couldn’t get the Xanadoo office to return our phone calls. 

I can’t say how disappointed I am with Xanadoo.  A few friends have asked me if they should try Xanadoo, and I always give them an emphatic “NO.”  Not only do they have subpar service, but they also chose to flat-out lie about what their service could do even when they were fully aware they were not telling the truth.  Thinking back, on the original visit the rep claimed one of their current clients was using a modem in a vehicle all the way from Wolfforth.  That is physically impossible with unidirectional antennas at that distance, so that must have also been a lie.

I have heard some people say they had an decent experience with them, but people’s experience seem to vary wildly based on how close to the antenna they were and what obstacles there was between them.  If there was any other type of data service you could get, I would definitely try it … I might even opt for dial-up instead of the horrible service and experience I had with Xanadoo.

From Hanselminutes.com:
Hanselminutes is a weekly audio talk show with noted web developer and technologist Scott Hanselman and hosted by Carl Franklin. Scott discusses utilities and tools, gives practical how-to advice, and discusses ASP.NET or Windows issues and workarounds.

If I only had time for one podcast a week, this would be the one I listened to.  In fact, if I was stranded on a desert island and could only pick one thing to listen to … well it wouldn’t be this, but if I could somehow get weekly updates I would think about it.

Carl and Scott seem to hit on random topics every week, but it somehow seems to either be something I curious about or didn’t realize I needed to know.  They don’t waste your time with the 10 minutes of small talk upfront, and Scott used to end quite a few podcasts with the line “Hope we didn’t waste your time”, which seems to be one of the driving forces in the show.

Scott has a unique look at software and technology, and there is just something about it I enjoy.  He has a lifehacker-type approach to development and life in general, and is all about finding clever tools that will help him save time or simplify his life.  Bottom line, Scott is a likable guy that cuts the chase, has practical advice, doesn't include fluff, and I can’t remember him ever wasting my time.

I wanted these tools to be first thing I reviewed, because I want everyone to know how amazing they are.  I recently switch to Vista on my production machine, and I tried to prioritize the software I installed in the order of how critical it was to being able to function in my job … the top of the list went something like this:

1. Office 2007
2. Visual Studio 2005
3. SQL Server 2005
4. Red-Gate Tools
   …

These tools are irreplaceable.  SQL Compare alone saves save me and my team a ton of time every week.  Red-Gate has great prices (most tools are $300-400), and I can’t remember ever running into a bug and have been using this stuff for over two years.  Some of this software has to be pretty intelligent in regards to how it orders updates, and in the hundreds of times I have ran it I only had undesired side-effects twice.  Here is what I use each tool for:

SQL Compare: Compares the schema of two databases, including tables, stored procedures, views, functions, users, and roles.  It looks at the structure of the databases … not the actual data contained in them.  It allows a user to see the differences between objects in an intuitive interface, choose which should be moved to the target database, and then generates a T-SQL script to make the changes.  This is the most useful tool for me, because this makes it really easy to move application code and database updates from the development environment to the production environment.

SQL Data Compare: Compares the data in two databases … not the schema.  Allows a user to view the individual rows that are different in each database, generates a script to update the target to match the source database.  I don’t use this quite as often, because you typically have a production set of data and don’t need to move actual rows from a development environment to the production environment.  But it comes in useful enough to justify the cost.

SQL Refactor:  I don’t think I have realized what all this tool is capable of, but just what I am aware of makes it pretty cool.  My team has to view/edit stored procedures written by another company that have extremely poor formatting to the point that they are almost impossible to read.  When you install this tool, it creates a menu item inside SQL Management Studio.  I have the ability to set options related to how I prefer my T-SQL code to be formatted (placement of things like columns, join clauses, subqueries and other things like wrapping, spacing, etc), and when I open one of those ugly procedures I can go in the menu to SQL Refactor > Lay Out SQL … and that’s it.  You can share the same settings between a whole team, and then make sure everyone formats procedures the same.  It also allows you to do things like “Expand Wildcards”, which intelligently converts a “SELECT *” to a list of qualified columns.  And one more really cool thing is that it can help you rename tables, columns, parameters, and other objects, and SQL Refactor will find all of the dependencies and change them accordingly.  Yes, I mean it … all dependencies (inside procedures, views, relationships, and other objects).  All this and more for around $300.

Conclusion: These Red-Gate tools are a no-brainer.  Compared to other development tools they are incredibly cheap, and their software quality is flawless.

http://www.red-gate.com

By Dino Esposito
352 Pages
http://www.amazon.com/Introducing-Microsoft-ASP-NET-AJAX-Pro/dp/0735624135

Publisher's Description: Get an expert introduction to the new JavaScript enhancements (code-named "Atlas") for Microsoft ASP.NET 2.0. More than a basic AJAX (Asynchronous JavaScript And XML) script library, the Microsoft implementation brings object orientation to JavaScript, together with enhanced client-side and server-side controls that greatly simplify coding while delivering enhanced Web experiences with any browser. Scheduled for release with the next version of Microsoft Visual Studio®, code named "Orcas," AJAX extensions and tools can be used by developers today. This book offers expert insights direct from the Microsoft product team and noted ASP authority Dino Esposito, as well as hands-on instruction and examples of Web development with AJAX. This ideal reference will be updated online, keeping readers up to date with the evolving tool. The book includes code samples in ASP.NET 2.0 created using C# and JavaScript.

My Thoughts: This is the hot, new technology in the industry and like a lot of its predecessors there are a million people claiming it is the biggest thing since the GUI.  Here is the breakdown of those on the bandwagon:

• 50% don’t have a clue what ASP.NET AJAX means, but they heard someone say it was cool so they want it
• 35% think they know what it is, but are really confusing things like AJAX, ASP.NET AJAX Extensions, the ASP.NETAJAX Control Toolkit, web services, and “Web 2.0” (which I am sick of hearing about).  This is the most dangerous group.
• 15% actually know what the heck is going on, and are reasonably excited

The Good: I admit … I have bought a few different books related to AJAX stuff: Professional Ajax (Wrox), Ajax Hacks (O’Reilly), and Programming Atlas (O’Reilly).  But this is by far the most useful book of them all.  Dino adequately covers the fundamental concepts that developers should know without going into too much detail.  He jams this book with a ton of practical information that a developer would actually use without the fluff.

He starts off by covering the basics of AJAX and the existing tools out there in 34 pages.  Then he dives into the heart of it with chapters on the Microsoft Client Library for AJAX, and the ScriptManager control.  There is even a chapter that covers the AJAX Control Toolkit, which is an open-source, community project containing a ton of components that you would usually expect to pay for.  Some of the other topics he includes are: partial page rendering, accessing application services on the client, and remote method calls.

The Bad: The only con was that the last chapter seemed like it was just thrown together.  When I was 2/3 of the way through it, I was thinking this book was almost flawless … but it took a steep nose dive at the end.  I figured the publisher probably put some pressure on Dino to wrap it up, because they wanted to be the first with a book after the release of ASP.NET AJAX Extensions 1.0.  This might have been smart business thinking, but the text reflected it with a few inaccurate or confusing statements.

Conclusion: Still an awesome book, and well worth the money.  One of the most useful books I have read this year.  Anyone who spends much time in ASP.NET, and would like to become more valuable should pick up this book and read it.

By Bill Holtsnider & Brian D. Jaffe
632 Pages
http://www.amazon.com/Managers-Handbook-Second-Getting-your/dp/012370488X/

Publisher’s Description: The IT Managers Handbook, 2nd edition provides essential information needed to manage the new responsibilities thrust on you (or the ones you would like to have): vital tasks such as creating budgets, evaluating technologies, administering compliance, and managing staff.

A completely updated and expanded second edition that provides practical, easily accessible management advice written specifically for new IT managers:

• Brings you up to speed on those business practices most critical to effective IT operations: recruiting, budgeting, resource planning, managing personnel, and working with vendors.
• Includes expanded coverage on such critical IT management topics as security, disaster recovery, storage, government/regulatory compliance, and project management.
• Organizes information modularly so you can delve directly into only the topics that you need.
• Provides a unique management perspective on those specific technical issues with the most significant business ramifications.
• Includes new material on key technology topics such as open source, wireless, handhelds, outsourcing, offshoring, and operations, as well as updated coverage of e-commerce, remote access, intranets, and LAN/WAN management.

My Thoughts: This wasn’t one of the most fun books I have ever read.  I typically prefer books with lots of code samples, and this was about all the other less technical aspects of my job … but all stuff I really needed to know.  There is some essential, mission critical information contained in those 632 pages that I just flat out needed to read, and if you are reading this you probably need to also.  It covers a gambit of information that is really useful in my day-to-day world, from the laws IT professionals need to be aware of regarding compliance to examples of effective email notifications for scheduling downtime and a ton of other stuff.  I probably reference it a few times a month, but am glad I did make time to read it cover to cover.