Book on Amazon

Finally someone has written an in depth beginners book for nhibernate.  Nhibernate 2.0 Beginners Guide written by Aaron Cure is just that and more.  Wow do I sound like a car salesman.  I was a little disappointed when I read Nhibernate In Action last year, because it was more of a reference than a tutorial.  This book is definitely what the title states, which is a beginners guide.  The book contains step by step examples of how to find, setup, and use nhibernate.  I highly recommend this book to anyone wanting to learn nhibernate.  By the way I think all .netters should do just that.

Pros

• love the beginning paragraphs
  • In simple terms, NHibernate does all the database work, and we reap all the benefits! Instead of writing reams of SQL statements or creating stored procedures that “live” in a different place than our code, we can have all of our data access logic contained within our application.
    With a few simple “tricks” that we’ll discuss in Chapter 4, Data Cartography, not only will our queries be effective, but they will also be validated by the compiler. Therefore, if our underlying table structure changes, the compiler will alert us that we need to change our queries!
• starts slow, which is perfect for a “beginners” book.  lots of hand holding and explanations of basics.  this is truly meant for somehow with no experience with ORMs.
• clearly shows you how to use log4net!  great bonus in a nhibernate book.
• briefly mentions all the major players in the nhibernate world, which is great for demonstrating options
  • Examples: fluent nhibernate, nhibernate.burrow, castle, spring ioc, etc.

Cons

• book uses basic aspx pages with custom controls in the examples.  I firmly suggest ASP.Net MVC over webforms.  But it may be too much to learn at one time if you aren’t familiar with either nhib or MVC.  So learn one first and then learn the other.  You won’t regret it.
• most examples are in c# and vb.net.  that’s good or bad depending on your opinion of vb.net.
• No HQL examples.  All query examples use the Criteria class.  This isn’t totally bad especially for beginners, but HQL should have at least been mentioned.

Chapter Notes

• chapter 1
  • clearly denotes which version of nhib the book uses and where to get it
    • Even explains the nhib release verbiage of “generally available”
  • shows basic examples of mapping file and how it relates to POCOs.  Good stuff for a ORM newbie.
• chapter 2
  • good advice for designing your database in logical way that avoids data duplication.
  • clear steps to download and setup a database using sql server express
    • Does mention that nhib works in almost any database, however all the book examples use sql server express
  • nice explanation of how tables relate to your classes
  • great introduction to OTM, MTO, MTM, and OTO relationships
  • good summary of left joins and how joins matter in queries for the different relationship types
• chapter 3
  • starts creating a simple class library application.  clear steps and good examples.
  • even addresses the somewhat hated nullable types and how to handle database columns that need to be mapped to types that can be null.
• chapter 4
  • nice explanation of what mapping means in terms of ORM software and how it functions as the glue that binds your objects to the database.
  • summary and examples of the most common used mapping types
  • gives examples of two mapping styles
    • xml
      • lists the two main complaints which are.. 1) too much xml 2) xml files are not compiled, so you don’t find bugs until run time.
      • provides great tip of adding the hibernate XSD to  your project so that visual studio will provide code completion for you and validate your mapping files.
      • important info about how to make sure the xml mapping files are compiled into your dll
    • fluent nhibernate
      • short example given that shows how using the “side” project http://fluentnhibernate.org/ can work without the xml mapping files.
      • pro is that mappings have to be compiled, so bugs/typos are found earlier
• chapter 5
  • creates console application to test the nhib code
  • shows step by step how to add references to the nhib dlls that you need to download
  • good definition of what a nhib session is and how it relates to an actual database session
• chapter 6
  • why you should and how to use log4net with your nhib project
  • excellent and thorough tutorial for using log4net
• chapter 7
  • nhib config details
  • mentions how easy it is to change databases by simply changing one config line
  • shows how to config nhib in an app.config or web.config
• chapter 8
  • provides example of Singleton DOA pattern
  • shows example of using a structure that holds all the column/property names for a class/entity.  this is done so that the column names in the structure can be used in criteria queries.  all this effort is done to avoid run time exceptions.  seems like a waste of time to me because you if you don’t update your structure every time your db is updated then you will still get runtime errors.
  • query examples using Criteria (at this point all examples have been using Criteria, none in HQL)
• chapter 9
  • in depth examples showing how to create custom controls to display data retrieved using nhibernate
• chapter 10
  • shows how to implement the login controls with nhibernate
• chapter 11
  • covers 11 code generation tools used to limit manual boiler plate coding.  I actually hadn’t heard of many of the ones listed.  Great bonus chapter.
  • nhib-gen, mygeneration, NGen NHibernate Code Generator, and T4 hbm2net seem promising
  • these tools create everything from POCOs to DAOs to services.

Related Posts

• NHibernate in Action – Book Review
• Outliers – A non technical book every freelancer/developer should read
• Configuring NHibernate in a Multiple Project Layout

Book on Amazon

Outliers “The Story of Success” by Malcolm Gladwell is a popular book. I heard about the book in a freelance discussion group at a developer conference. I quickly ordered a used copy from Amazon. It’s popularity became very apparent when multiple people, that saw me reading it in an airport terminal, asked if it was any good because they had heard it was. My answer is yes. The book has been reviewed many times (795 on amazon alone) so to avoid duplicate statements I will give my brief summation along with my comments about how the theories in the book apply to software development. If you have read the book please comment with your thoughts. If not I suggest you do because it’s a quick, thought provoking read.

Summary: The book is NOT a 12 steps to success type book, I really hate those books. Gladwell presents the theory that success is not a trait or a gene that only some people have. Gladwell proposes that there are no simple rags to riches stories where a person builds an empire solely on their own. With scientific studies and research to back up the theories Gladwell explores how opportunities and advantages provide the gateway to success.

• 10,000 hours (very popular topic from the book)
• No one succeeds without many, many hours of preparation. No one.
• Examples from Bill Joy(co founded Sun) to The Beatles are given.
• My thoughts: Turn off the xbox360 and the TV and learn a new language, framework, or pattern. Then repeat.
• Luck
• Some people that prepare will be rewarded with incredibly rare opportunities.
• My favorite example in the book is a list of the richest people ever. A large number were from a 10 year period in the mid 1800’s. That time period gave a few lucky individuals the opportunity to become tycoons because of culminating economic and technical advances.
• My thoughts: So if you are not lucky enough to be learning the types of technical skills that will benefit you, then take it upon yourself to make your own luck and find a position that will.
• IQ is not all you need
• The book covers in depth the story of Chris Langan who has an IQ of 195, but has never attained a college degree or high profile professional career.
• My thoughts: To succeed in software development you need communication skills, imagination, and technical skills(IQ). You need to know how to inform/educate non technical people and how to debate effectively with colleagues.
• It takes a village
• No body makes it alone. We all need support from family, friends, and colleagues.
• Every freelance book or article I read says to have a partner.
• Love what you do
• Great quote from the book: “Hard work is a prison sentence only if it has no meaning”
• My thoughts: You know if you love your job or not. Stop thinking about finding a satisfying job. Update your resume and go find a job you will love. It won’t find you, unless you are one of those really lucky people the book mentions.

Another excellent review of Outliers: http://www.markhneedham.com/blog/2009/01/06/outliers-book-review/

Related Posts

• NHibernate 2 Beginner’s Guide – Book Review
• If You Want to Have Cities You’ve Got to Build Roads
• NHibernate in Action – Book Review

Book on Amazon
All summer I meant to read the book “NHibernate In Action”. I finally got around to it, better late than never I guess. In my opinion this book is aimed at higher level programmers such as lead developers or architects. The book does not contain clear step by step examples of how to get NHibernate running. However it does provide in depth conceptual reasoning why anyone would want to use NHibernate along with reference style examples. If you are trying to learn NHibernate  you are better off reading a few online tutorials first and after that read this book so you can understand exactly what NHibernate is doing and how it does it. Below are some book pros & cons, NHibernate links, and chapter summaries.

Pros

• Examples are all in c#
• Shows config examples for NHibernate 1.2.1 and 2
• Promotes proper design patters often references popular pattern books
• Makes note of minor current bugs or missing features that may cause issues or confusion
• Provides suggestions for when to use something other than the default NHibernate settings
• Mentions how NHibernate can use the features of multiple RDMS, not just SQL Server

Cons

• Download and install instructions were vague
  • I downloaded NHibernate 2.1.0 QA from SourceForge after finally finding the link on nhforge.org. From there I followed the install notes in the downloaded zip file.
• Examples do not use Generics
• Doesn’t provide a link or even a suggestion to where you can download the NHibernate.Mapping.Attributes library which lets you use features similar to the annotations in Hibernate 3
  • I found them here: http://sourceforge.net/projects/nhcontrib/files/NHibernate.Mapping.Attributes/
• Shows attribute and xml mapping examples randomly. In my opinion it would be better if one or the other was used consistently.
• Jumps from definitions to examples. No clear step by step examples
  • I would say this book is more of a reference than tutorial

Helpful NHibernate Links

• NHibernate community site
  • Great short tutorial
  • NHibernate docs
• NHibernate Google Group
• Stackoverflow NHibernate questions and answers
• How to use MySQL with .NET
• Databases supported by NHibernate
• Common exceptions

Chapter 1

• Basic definitions of persistence, sql(sql not sql server) databases, and layered development
• Doesn’t mention the testability benefits of layered development
• Compares persistence layer choices available with .Net
• Makes the case that LINQ and Entity framework will not replace NHibernate
• Definition of ORM
• Addresses the performance concerns of using ORMs
• Author tries to convince people to use ORMs, this part needs a little salesman ship but I guess if someone is open minded enough to read this book then they don’t need much of a sales pitch.

Chapter 2

• Some basoc instructions for how to download and install the NHibernate dll
  • con: Could use a little details in this section about how to use the versions that don’t have msi installers yet like the 2.1.0.GA release I downloaded.
• Shows very simple examples of saving and loading an entity
• Then shows you a basic xml mapping document
  • o Shows a mapping document for versions 1.2 and 2.
• Quick glance at the NHibernate api and in depth notes on important interfaces
• Very short section on logging with log4net

Chapter 3

• Good section on the benefits of having a transparent persistence layer
• Discusses the anti xml config file movement.
  • However doesn’t mention the fact that poorly designed and overly complicated schemas are one reason for the back lash. Also never mentions CoC.
• Discusses using attributes as meta data
  • IMHO way more time should have been spent telling the users how to setup/install the mapping dlls needed to use this feature
  • Does show many examples of how to use the attributes and what the xml version of the meta data would look like
• This chapter provides information about the hibernate mapping elements and options
  • It is a mix between a reference and tutorial.
• Good section on object identity vs equality
• con:  Gives an explanation of what primary keys are. Surely anyone reading this book knows already knows what primary keys are.
• Good short explanation of the different types of primary key creation that NHibernate supports
• Long discussion on database and object model design
  • table per concrete class
  • table per sub class
  • table per class hierarchy

Chapter 4

• Explains object identity scope. probably a little high level for low level developers
• Explains different options for Equals and HashCode implementations
• Automatic dirty checking
  • Changing an object in an ISession and committing will result in those changes being automatically reflected in the database
• Clearly denotes the different cascading persistence options
• Details the different object retrieval options
  • Retrieving by identifier
  • HQL
  • NHibernate Criteria API
  • Native SQL queries
• In depth discussion of fetching strategies and how to implement each one
• Short section on batching and how it can speed up queries for selecting collections
• Provides common sense ideas for analyzing NHibernate’s performance

Chapter 5

• Background on database transactions, unit of work and conversations
• Excellent section on transaction isolation
• Background on ORM caching

Chapter 6

• Starts with more definitions and comparisons of entities and value types
• Nice chart showing how NHibernate mapping types relate to .Net types
• Give in depth example of creating a custom mapping type
• Nice tips on controlling collection sorting with mapping settings

Related Posts

• NHibernate 2 Beginner’s Guide – Book Review
• Configuring NHibernate in a Multiple Project Layout
• ASP.Net MVC Book Review and musings

Well, as I related in a post on my personal blog before this shared blog came into being, I was going to read a book every two weeks and give a review of it. I should have said that I’d read 200-300 pages per week instead. My latest book is 800+ pages, and it took me three weeks, even when I skimmed several pieces of it. It was, however, an outstanding book.

If you write software, this book is an absolute must-read. If you’ve never written an automated test, it will convince you why you should. If you’re test-infected, it will give you advice and principles to follow that guide you toward more effective testing and, ultimately, more effective software. For anyone in between, this book has something for you, too. It’s written in a language-agnostic way and has advice applicable to testing with any of the “xUnit” family: any test framework that works along the same lines as Java’s JUnit.

xUnit Test Patterns
Refactoring Test Code
by Gerard Meszaros

As its name suggests, it’s a patterns book, which means that Mike would like it because a large part of it is a catalog of various test-related patterns that the author has collected. Another chunk of the book is taken up by a catalog of test smells. This still leaves plenty of room, though, for Meszaros to provide a thorough introduction to software testing–primarily unit testing, but with plenty of consideration for other test scopes as well–and to give a detailed overview of best practices in testing.

Part One of the book is the narrative, non-catalog part and could be a book all by itself. It covers a lot of theoretical ground with topics like goals of automated testing, guiding principles to consider when writing tests, and various philosophies of testing along with their pros and cons. On the more “practical application” front, there’s a basic introduction to the internal workings of the xUnit family frameworks, which is foundational knowledge for many patterns, and a ton of practical advice revolving around real-world examples of difficult testing situations and methods of dealing with them. You could read just this part of the book–under 200 pages–and come away a better developer for it.

Part Two is the catalog of test smells. Each smell is the formalization of a testing problem that was discussed in Part One. A statement of the problem, its symptoms and possible causes, and various suggested solutions are all collected into a neat, tidy package for easy access. The smells cover a wide variety of things from the seemingly trivial difficult-to-read tests to major systemic problems like unreliable test suites due to sporadic test failures.

Part Three is the pattern catalog, where the solutions to aforementioned problems and best practices are formalized. Each pattern has a brief summary up front, a description of how and when to use it appropriately, examples of how the pattern looks in code (in various languages), and examples of how to refactor problem code to solve the problem effectively with the pattern. The initial summary is highly useful in that you can read through the summaries of all 60 or so of the patterns in a very short time and have a feel for which ones you should look into more deeply for a particular situation.

I have to say one more time that you must read this book! It pulls patterns, practices, and more from many other sources and organizes them all in a well-written, easy-to-read reference that will provide a strong foundation for testing efforts in any xUnit framework. Beyond that, I’ve yet to mention the author’s efforts to establish a common vocabulary of test patterns by assembling them all in one place with a strict system of names. While this may seem trivial in comparison to the content of the patterns, the lack of such a vocabulary can lead to real difficulties in communication when four people use a name like “Test Stub” in four very different ways. Learn a better way.

Get this book. Read it. Use it. Live it.

Related Posts

• PHP Framework Comparison
• Read HTML with Java – Then 7 Fun Things to do to It
• List of Version Control Web Sites

This is a book review of Pro Java™ EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework

About the Book

Apress describes this book as

Pro Java™ EE Spring Patterns focuses on enterprise patterns, best practices, design strategies, and proven solutions using key Java EE technologies including JSP™, servlets, EJB™, and JMS APIs.

This Java EE patterns resource, catalog, and guide, with it’s patterns and numerous strategies, documents and promotes best practices for these technologies, implemented in a very pragmatic way using the Spring Framework and it’s counters.

The book was written by Dhrubojyoti Kayal. Dhrubojyoti works as a senior consultant with Capgemini Consulting. He has more than five years of experience developing and designing applications and products leveraging Enterprise Java technologies. His areas of interest include the Spring Framework, ORM, SOA, refactoring, prefactoring, and performance engineering.

In this book the author takes us through the process of refactoring a legacy system built without using patterns or the Spring Framework into a shiny new system leveraging Spring and design patterns. Throughout the book he takes us through this practical, real-word example.

Introduction to the MVC Pattern

The first chapter introduces you to the MVC pattern. I think that this book is for a well versed J2EE professional developer, who would probably be familiar with the pattern, so this chapter may have been overkill. However, the basis of this book is to refactor an antiquated web application to use Spring and the Spring MVC, so a clear and thorough understanding of the MVC pattern is necessary. Most readers of this book can probably skip this chapter. On the other hand it is written well enough that it would serve a good resource for any rookie developers that you might be working with who need to learn this pattern.

Patterns

Each chapter of this book takes you through the concepts of a common pattern, describes how the Spring Framework is used to implement that pattern, and then replaces the legacy insurance system code with new spring code. Once you get into the patterns, the book is divided into four major sections. These sections are

• Presentation Tier Design Patterns
• Business Tier Design Patterns
• Integration Tier Design Patterns
• Crosscutting Design Patterns.

This division helps to keep the conversation between the author and the reader focused and also makes it easy to find later when you come back to reference this information.

The Best Part

My favorite part about this book is that it is a patterns book. I like to read books based on patterns more than any other type of book. Patterns books are naturally broken down into small, manageable chunks of information. When written, patterns are usually described using a common, easy to follow template and are small enough to read an entire pattern in one sitting, whether that sitting be while you are eating your lunch or a quick read before hitting the pillow. Because they are written this way, it is easy to read this book very quickly and easy to find what you are looking for when you come back later for specific information. Pattern-based books are great.

I also liked this book because it takes you through all the layers of a real-world system. As developers we all have to work with legacy code. If you don’t your very lucky. Because this is real world it is very easy to follow along with the author and the project and see the benefits of Spring and refactoring to patterns.

Needs Refactoring

It’s a good, well-written book, but there are some things that I think need to be changed.

First, as with any book with code examples, there is some odd code that should be rewritten or removed. For example, there is a business bean that has a DAO injected into it via a setter. However, this bean also contains a getter for that DAO. This is not common practice and, in my opinion, not recommended.

And second, all of the presentation patterns are in a single chapter, and all of the business and integration patterns are in their own chapters. I think each pattern should have had its own chapter. I just prefer the clearer boundaries between patterns and I think it would make finding these patterns later, when I come to reference the book, a little easier.

You Should Read this Book

You should read this book if you are a developer who uses Spring, and especially if you use Spring MVC. This is a great resource and a great way to learn about how Spring utilizes patterns internally to implement its services. Of course it also shows you how to use Spring to add patterns to your current code base. You should read this book if you use an MVC framework that is not Spring MVC and are considering Spring MVC for  your next project or are considering adapting Spring MVC to your current project. While this book deals with more than just the Spring MVC, the entire presentation tier section is based on it.

Or Not…

I do recommend this book to most developers, however you should not read Spring Patterns if you are not well versed with J2EE/JEE and the Spring framework. If you are looking to learn Spring, there are other books that might be more suitable.

Here are some last notes, straight from Apress, about this book:

• What you’ll Learn:
  • Get an introduction to enterprise Java/Java EE application design patterns.
  • Simplify enterprise Java design using the popular Spring Framework.
  • Examine presentation, business, web, and integration tier design patterns and best practices, including cross–cutting design patterns, AOP, etc.
  • See how the enhanced and up–to–date pattern catalog compares to core J2EE design blueprints.
  • Learn how to use comprehensive source code and configuration information.
  • Develop order management system requirements for the first in–depth enterprise application case study.
  • Design your order management system application using the final case study.

Table of Contents

Finally, here is the table of contents:

Related Posts

• ASP.Net MVC Book Review and musings
• NHibernate 2 Beginner’s Guide – Book Review
• Outliers – A non technical book every freelancer/developer should read

ASP.Net MVC musings

• ASP.Net MVC is a CoC MVC framework, it’s not a “full stack” framework. You still need to implement some type of database layer.
• Traditional ASP.net web forms attempts to hide the core parts of web development HTML, JS, CSS. ASP.Net MVC does not.
• Learning a pattern like MVC in web framework that allows developers to be aware of HTML, JS, CSS will only benefit you as a web developer.
  • If you actually understand how web pages work it makes you a better debugger and a more well rounded programmer. You are able to more easily apply your knowledge and skill set to other languages/platforms. I know that some web form developers do know the details of web development, but in my opinion most do not.
• The fact that ASP.Net MVC makes it easier to test will not appeal to people who have never written a unit test in their life. You have to convince such people by showing a real world example demonstrating how test coverage can save you loads of time and money in the maintenance phase of application development. But at that point you will only get architects and project managers to buy in, the lazy developers that fear learning anything new will still avoid ASP.Net MVC like the swine flu.
• The fact that the MVC pattern is a common pattern among other web development environments such as Java and PHP will also not appeal to most Microsoft developers. However the really smart ones will realize that more common knowledge will only help if you ever have to do any type of development other than microsoft development

Book Review – Pro ASP.Net MVC Framework – Steven Sanderson

Book on Amazon I am a Java, PHP, and .Net developer which may make my opinion worthless to some Microsoft zealots but I thought I would type up my thoughts on this book anyway. Overall I found this book to be a great way to learn ASP.Net MVC. It has great examples and enough background material to bring people new to the MVC pattern up to speed. Below are my pros and cons along with notes on chapters 1-13.

Note about the cover.

One thing I found interesting is that the cover says “Discover the biggest innovation in Microsoft web development since asp.net 1.0″. I find it amusing that something as old as MVC web frameworks can be called an innovation for asp.net development since MVC frameworks are nothing new to web development. Heck they are not even new to ASP.Net development. See MonoRail .

Pros

• Provides good definition of MVC and explains why you want to use it
• Overall all the examples are clear and concise
• Gives examples of how to test every part of ASP.Net MVC
• Moves quick enough for someone with MVC experience and slow enough for someone with no MVC experience
• Great chapter on web site security
• Book often demonstrates C# 3 language features

Cons

• Database examples use LINQ to SQL.
  • As many have noted this isn’t a major con. It was probably used to keep the examples shorter. Whether you like LINQ to SQL or not that is a good thing.
• No mention of Mono project or any hints of how to get ASP.Net working with Mono.
• Book examples are for the “real” version of VS2008 not the free VWDE2008.
• Does not provide a good example of using a validation utility such as XVal or Data Annotations

Chapter 1

• An adequate history lesson for those unfamiliar with MVC.

Chapter 2

• A great chapter that quickly and easily shows you the basics of ASP.Net MVC

Chapter 3

Book on Amazon

Related Posts

• NHibernate in Action – Book Review
• Spring Patterns: Best Practices and Design Strategies Book Review
• NHibernate 2 Beginner’s Guide – Book Review