Author: Dan Clark
Publisher: Apress, 2011
Pages: 378
ISBN: 978-1430235309
Aimed at: Beginners in OO programming and C#
Rating: 5
Pros: Easy to absorb and straight to the point
Cons: Must read the whole and in order
Reviewed by: Nikos Vaggalis

It’s easy to start building something useful without fully comprehending the Object Oriented Programming concepts, as well as not following an Object Oriented Design methodology and everything would look in order, but in reality the end result would be a fragile eco-system that might show its flaws much later on; then, attempting changing or modifying it would prove painful and counterproductive.

Most books on teaching programming languages focus too much on the language and syntax rather than the OOP concepts. This book reverses that process by using the language as the medium to teach OOP and design concepts and not the other way around - this is a subtle but very important point.

Theoretically, you could just go through the first half of the book and apply what you’ve learned to any language (if you look at it from an OOD view), as concepts stay but syntax can change. However, as theory and practice go hand in hand, it is best to read through the whole book and follow the code examples to solidify understanding.

The first half of the book concerns itself with system analysis and design using UML; identifying requirements, breaking the system down into parts and applying diagrams to imprint the relationships and messaging between those components.

Chapters 1-3 start from point zero, no pre-qualification required, and get you through pretty much standardized business examples; a flight booking website, a library and a video rental application. On the way you will use the models of Software Requirement Specification, Use Case scenarios, Class, Sequence, Collaboration and Activity diagrams before you start coding. So either put your keyboard down and get pencil and paper or start using the UMLlet CASE application recommended by the book’s author to get on with the diagrams.

Chapter 4 attempts to apply the design lessons learned from the previous chapters to designing an OSO (office supply ordering) application from scratch, which also completes the methodology part of the book. Our projects’ design is now complete and now we have to translate the diagrams into the actual software. But in order to do that we have to actually start seeing some code!

That is what the second part of the book aims at, as we get into more practical territories. Chapter 5 gives a short intro to the .NET framework and Visual Studio. Chapters 6 and 7 named 'Creating Classes' and 'Creating Class hierarchies' is where you finally start coding. They provide a very quick but crisp explanation of what a classes, attributes and methods are and how to translate them into code. They also take a look at encapsulation, the use of constructors, method overloading , inheritance , polymorphism, the usual OOP features. The explanations are not in depth and time consuming but quick and straight to the point. Chapters 8 and 9 go through event processing, exception handling and using collections. What I found refreshing for a beginners' book is that it also discusses Asynchronous method calling and Generic collections

Chapter 10 shows how to work against a database by using the standard ADO.NET libraries as well as an ORM solution using EF. Chapter 11 goes through building a data bound desktop client-server application while Chapter 12 goes through the web based equivalent using Silverlight and Chapter 13 shows how to implement a web service

All-in-all the coding part of the book provides the equipment that a programmer must have in his possession for building a modern,  business-wide application. After the tour completes we revisit the OSO application but now will actually attempt to utilize it since we now have gained the required coding experience.

Summing up, this is a book that won’t get deep into the OOP concepts.For example it doesn't show how inheritance breaks encapsulation, it doesn't consider the issues with single inheritance, multiple inheritance and the diamond problem or when to use an interface vs an abstract class, versioning etc. I think this is justified since it's a total beginner's book and as such should provide the minimal requirements to get one started and place him into the OOP mindset; getting into deep design issues at this stage would potentially distract and confuse the reader.

I would not be surprised if the book was adopted as  part of the curriculum of a class on OOP (with UML) 101. It is a coherent book that you have to follow in order, to get to the end result. It uses many metaphors, mapping real world examples to programming concepts, and use cases that correspond to the requirements of a modern business application.

If you are looking to get a hands-on introduction in OO programming and design and on the way get also exposed to C#, then you will find that this book delivers.