Steve McConnell requires no introduction. Remember in Code Complete and Rapid Development Steve said Software Estimation really required a full book. Finally he found the time to aggregate all that has been written on the topic, sprinkle with his own wisdom and produce a Software Estimation guide intended for mere mortals rather than specialists in the field.

There are three main sections to the book:

1. Critical Estimation Concepts
2. Fundamental Estimation Techniques
3. Specific Estimation Challenges

Over the 18 years in IT four of the sixteen projects I participated in failed, in every case problems grew from wishful thinking and unrealistic estimates. If every IT manager read and understand chapter one if this book IT failure rates would plummet overnight, but then there would no hugely late projects for expensive IT consultants to rescue either Admittedly chapter one teaches an experienced developer little, but I left with a better vocabulary to translate my experience into terms non-technical managers are likely to understand and agree with. The diagram called ‘Cone of Uncertainty’ and the section on why underestimation is really dangerous are prime examples that

Interestingly in every failure I saw serious problems mounting well before the projects were canceled. Trying to forewarn management generally results in being labeled a trouble maker, so before you batter a pointy-haired manager with this book make sure you can easily find another job!! I had to once; of course politics and wishful thinking did not deliver working code and the project failed. Both people responsible for firing me were fired for incompetence, and the client tells me they now have a much smaller team producing much better results after the purge; what a surprise .

Recently I presented on Software Estimation at the local IASA chapter, the material was based on this book (with Steve’s permission!) and people loved the content – it seemed like every single person present came to me and said they enjoyed the material or emailed me later.

Offshoring is here for good, get used to it. Only last month I sold my recently delivered ’07 BMW to an Indian working in the US. He is an off shoring specialist with no coding skills whatsoever! The offshoring trend is way more advanced than you probably think. Oh yes, he paid cash for the car too, these Indians are smart people…

So what are we to do? In his first book ‘My Job Went to India’ Chad Fowler has delivered a ‘self-help’ guide for Western developers. Of course you dear reader, as a blog devouring overachiever, 80% of this book will be common sense. During chapter one I almost tossed it back on the bookshelf, but Chad’s anecdotes from his time in India are pretty amusing, and chuckles from a tech book always keep me reading As the book progressed tips appeared that I bet even you too can learn from. The chapter on Marketing Yourself is something I wish I had read ten years ago.

The cover of the book was my IM avatar for a while – as hoped it generated quite a few laughs, but most friends had never heard of the book, hence this review.

It is an easy read and at only $13.57 from Amazon I suggest everyone pick up a copy

Is it possible for book to have a more niche title? Interestingly to broaden the market appeal examples are in both C# and VB.Net; I find it hard to believe anyone interested in reading a book on Generics cannot read C#.

You have already read about Generics in Jeff Richter’s CLR via C# and possibly Jesse Liberty’s Visual C# 2005 too. Today the standard developer quote about Generics is that they are easy; just use List<T> and be on your merry way. Amazingly just that one BCL Generic has removed almost all type-unsafe code from our assemblies.

Recently I was binding a GridView to a custom collection. Naturally the collection implements List<T>, but I wished to sort the GridView on several columns. After expecting auto-magic in GridView to do the sorting for me, it was disappointing remembering about ObjectDataSource – this means we still need to do manual labor so I looked for a reusable solution. Long story short after pinging GridView whiz Marcie 60 seconds later this book was on my desk.

Reading of chapters 1->7 is required reading for anyone wishing to remain a senior .Net developer/ architect. This readability book is not on par with work by say Richter or Esposito, and where is the bold highlighting in code samples that point us towards the salient snippets? Other than these complaints, the book fulfilled its purpose and I now have a much deeper knowledge of generics. Until my comfort level increases List<T> the mainstay of my Generic usage, but I suspect that as time progresses we as a community will leverage them much more.

Before Marcie kicks me in the face I must return her book. Hence I’ll be putting an order into Amazon for my own copy, as I need to revisit a few of the more technical areas to solidify my knowledge. IMO $25 with free shipping is a bargain for this knowledge, please buy via my link and put another $2 into the Lockwood retirement fund, LOL!

All you really need to know is the following

• . This is one of the best written technical books I have ever read, and is an excellent introduction to Team System
• . If you have been working with Team System for some time this book is unlikely to teach you much, it is purely an introduction

The approximately 300 pages are filled with riveting content (disclaimer: I am a big fan of formal processes), and only uses screenshots where necessary. The book is far from another big font/ screenshots-on-every-page Barnes and Nobel shelf filler.

As you may expect the book begins with an introduction to Team System, Test Server and its related Client Applications. Beyond these chapters, things get really interesting as Richard explains the different major roles in team system, which as we know related to different skus of Visual Studio. For each major role Richard covers the tools provided in that area, and major features. It was interesting to see that Testers do not get much in this release of Team System – this did not surprise me given Mercury’s dominance in this area. It was interesting to read in the latter parts of this book that Mercury are planning add-ins for VS2K5. Note: Developers are looked after in the testing department, but your SQA team does not get much.

Part three of the book covers MSF 4.0, MSF-Agile and MSF-CMII. Personally I think this material is better suited to a classroom, as I found it difficult to keep up with all precise terminology used by each approach. After re-reading the first pages again and again I ended up skim reading most of part three.

Interestingly the best part of the book is the only part I can criticize. Appendix A is ‘A Day in the Life of Team System’; it presents a summary of using Team System on a three month long project. This section was very helpful to me in tying the whole process together, but I just feel it was not presented in the best manner. With a pen I highlighted the key terms in the storyboard to show what part of  team system was used when, but I feel the waffle outweighed talk about team system. Most people reading this book with have experience with many projects already and we just want a rapid summary.

All-in-all this is possibly the best technology book I have read since Code Complete and Writing Secure Code. Much of the material in this book will be out of date sometime next year when I expect we’ll see the second version of Team System, but I believe Richard is capable of writing a classic book that will stay on our bookshelves alongside Steve McConnell’s work.

Let’s start by saying that I loved this book. While in a speakers lounge once I picked it up from the sky-high give-away pile, started reading, got engrossed and well… it ended up travelling the 500 miles back home with me!

This is a book that would have been very useful when starting my .Net career. It is ‘simply’ a collection of nasty traps that .Net can lead you into. The book contains 75 separate gotchas organized into related sections.

Some gotchas are just that, but others explain tricky areas such as COM interop. Of particular interest to me was garbage collection and the Dispose()/ Finalize() coverage. I already knew everything that was written in these chapters but the concise manner in which they were written helped me collect my disjointed knowledge together. After reading chapter 5 I can confidently say that I understand garbage collection basics and the relative merits of dispose and finalize. The COM interop was of particular interest too. I had done this on a previous project, but was simply copying example code from newsgroups. This book gave a better idea of what happens with memory beyond us calling into the .Net RCW.

It is difficult for me to say how much of the book is out of date because of .Net 2.0 because I only have three months 2.0 experience. From what I have seen so far in 2.0 it looks like most of the gotchas are still valid. A gotcha does not mean that it was a flaw with the .Net design, just that somethings are tricky/ unexpected such as exceptions thrown from thread pools are lost. As you can guess I recommend people at least borrow this book. When (if?) a v2.0 of .Net Gotchas hits the shelves I recommend checking it out. The only bad thing I will say is that if you are experienced with .Net do not expect much of this material to be brand new, you will have heard of most issues before but probably not seen them documented quite so well.

This book is aimed at developers already experienced with .Net 1.0 and 1.1. It aims to offer a quick introduction to what is new in .Net 2.0 and VS 2005.

The first chapter in the book covers C# 2.0 and the book is very much worth buying for this chapter alone. Features covered by the chapter are as you would expect: Generics, partial types etc. We have been hearing and reading about them in the MSDN magazine for over a year. Still, it was very useful spending a couple of hours reading this chapter and nailing down each topic. It was also great to see the new covariance support for delegates covered, which I imagine is included to keep us hardcore happy.

It was a shame to spot a simple technical error: the book states that static classes cannot have a constructor. How this was not picked up proof-readers I have no idea. Just in case the CLR team has started taking mind altering drugs while designing 2.0, I knocked up a quick sample with a static class + static constructor and it worked fine.

So on to the rest of the book. Well there are lots and lots of page filling screenshots covering the new Visual Studio, WinForms, WebApps and Data Binding etc. These may be of use to less experienced developers, but I would have preferred simple short sections covering new features. Walking an experienced developer through how to setup a masked text box (>4 pages!) was not useful to me.

Summary: If you are just about to embark on your first .Net 2.0 project I recommend buying this book first chapter alone. It won’t take long to read, and then you can pass it to another team member. I do expect this to be a book you will use for reference.