I really enjoy reading books about java and software development. My favorite type of book is the patterns books. Patterns books are great because the chapters are usually short and very focused. So you can read a chapter over lunch, or before you hit the pillow and usually not put the book down in the middle of a 30 page chapter.

I am in the midst of reading and reviewing Pro Java™ EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework. Reading this book got me thinking about all of the other patterns books that I have read and really enjoyed. Here are my favorite software patterns books.

Core J2EE Patterns: Best Practices and Design Strategies

I think this was my first patterns-based book. I got a free copy when I was enrolled in a week long java patterns and architecture class in 2002 or so. I now have two copies on my bookshelf. One for me and one to lend out to friends and colleuges.

Core Patterns starts by introducing the concept of software patterns, then takes a unique approach by describing common J2EE anti patterns and then discussing the refactored solutions. This allows a straight-through reading for those unfamiliar with patterns or use as a reference guide for experienced pattern users.

The Manager Pool: Patterns for Radical Leadership

Of all the patterns books that I have read, I think this book has the most chapters at a whopping 61. Its also my favorite. I think its my favorite because it sort of on the fringe of software development, so I don’t feel like I know as much about management. I also like it because I could relate to most every pattern either as a subordinate or as a manager.

This fun book identifies patterns such as Tribal Language, Leviathan, and Unique Place. The chapters are short and quick to read. This book will help you communicate more effectively, understand your subordinates, and make you a stronger software manager.

Pro Java™ EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework

I am currently reading this book. The author has a poorly written java web application that uses no model-view-controller. He takes you through the refactoring of the project. He explains a pattern, and then discussues how the Spring MVC implements the pattern. It is common for the next pattern to build on the previous, so this book is a little harder to jump to an arbritrary chapter and start reading, unless ofcourse you know the patterns aready.

This book takes you though the presentation layer, business layer, and integration layer and discusses how Spring uses and implements patterns throughout each layer of the software. A great Spring reference or a great MVC reference. I am glad I got this one for my bookshelf.

Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML

This book opens with background on pattern research, including the groundbreaking design patterns. It goes further, with 41 software patterns, all illustrated with UML diagrams and sample Java code. Early patterns, such as Delegation and Proxy, show how classes can work together without relying on inheritance. Next come creational patterns, such as the Factory and Builder patterns and the newer Object Pool pattern.

These pages turn out to be a great resource not only for patterns, but also for Java and UML. If you read this one and enjoy it, there is also a second volume.

Design Patterns: Elements of Reusable Object-Oriented Software

This book was a little more difficult to read. Its much more academic-oriented, rather than written to be a casual read. It also goes deeper into the pattern than most other books do. I guess that makes it a good reference. This is one of the only patterns books that I have read that delves into the user interface.

The downside with this book, in my opinion, is that its geared towards C++ software development, so as a java developer, I spent more time trying to understand the code examples than I did reading and understand the patterns.

Check out the table of contents.

Software Architecture Design Patterns in Java

Covering 35 patterns, a long introduction to UML, and a web hosting company case study, this book weighs in at almost 500 pages. This one is practially a design pattern encyclopedia, so if you can only have one design pattern book on your shelf make it this one.

This book relys big on examples and has become a fundamental book for newer and older developers alike. After reading this one I think you’ll find yourself using patterns names more often in discussing your software.

Anti-Patterns and Patterns in Software Configuration Management

To end, an anti-patterns book. And to be honest, This one I have not read, but its next on my book list becuase it is on a topic that so few developers are experts in or sometimes even carry a conversation in. This book is coming up on 10 years old

As I understand, most readers of this book can really relate to most every pattern because their organizations are so bad at configuration management. This could give you the leg up to show off you knowledge and help your organization become more successful in the art of software development. At least thats what I hope it can do for me.

Thanks for reading my list. Now I have to ask, have you read any of these? Do you have any comments on them? Have you read any great patterns-based books that you would recommend?

A great way to determine if you want to buy a book or not is to review the books table to contents.

Pro Java™ EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework by Dhrubojyoti Kayal

• Describes a catalog of patterns used across the three tiers of a typical JEE application
• Provides implementation details and analysis of each pattern with benefits and concerns
• Describes the application of these patterns in a practical application scenario

And finally, an overview of each of the patterns that are reviewed.

Search This Book

• Published by Apress, August 2008
• 416 pages
• ISBN 1430209739

The Good

• Numerous practical examples from the Netbeans API and the JDK.
• Each chapter introduces a concept that could profoundly change your code.
• Practical situations with concrete examples.
• Explanations for novices and experts.

The Bad

• System.out
  .println
• Have to read Theory before getting to the practical exapmles.
• Subtitled “Confessions” ?

• Purchase from Amazon.com

About the Author

Jaroslav Tulach is the founder and initial architect of NetBeans, later acquired by Sun. As creator of the technology behind NetBeans, he is still with the project to find ways to improve the design skills among all the programmers who contribute to the success of NetBeans open source project.

Intended Audience

Apress.com, the publishers, describe this book as being recommended to every API architect who prefers a bit more engineering design over a purely artistic one. but this book is really much more for anyone who writes code that anyone else consumes - and who doesn’t do that? This book is for any developer who is not brand new to software development.

Selected Chapter Highlights

There are 19 chapters. There are a couple of dull chapters, but by far the majority are very interesting, applicable, and well laid out with introductions and examples of most every concept.

Chapter 1: The Art of Building Modern Software

The first chapter was tough to get through, but it does introduce a key concept of API design and a focus of many discussions throughout the book: cluelessness. Jaroslav suggests that cluelessness supports “the most promising development style.” The pragmatic use of the bulldozer approach: reuse components that are already available, compose applications form big chunks of premade libraries, glue them together, and make sure it works even without fully understanding how it works.

Chapter 2: The Motivation to Create an API

Chapter 2 is important in that it lays out, as the titles states, “The Motivation to Create an API.” This chapter is interesting and fun to read because it lays out exactly why you are reading the book. The biggest point that I took away from this chapter is that APIs are for human beings - for other software developers like yourself - not for computers. And also that not all projects need an API, or at least not a high quality API.

Chapter 5: Do Not Expose More Than You Want

This chapter is the first of many that represent the reason that you bought the book. This chapter starts Part 2 of the book titled, “Practical Design.” Here, Jaroslav begins describing some practical API designs and even some design patterns. We get into applicable sections like “A method is better than a field”, “A factory is better than a constructor”, and “Do not expose deep hierarchies”. This is one of those chapters that you will come back to and read a few times and will refer to in conversation.

Chapter 8: Separate APIs for Clients and Providers

Chapter 8 was one of my favorites. I lead an open source project with both an internal and external API under development and this chapter was right on point for our efforts. This chapter explains the differences between, and how to package APIs for clients and APIs for providers. Jaroslav explains how if you mix your API and SPI together within a single class, then you can never modify the class, stating that adding a method is forbidden because of the contract for SPIs and removing a method is forbidden because the contract for the APIs.

Chapter 10: Cooperating with Other APIs

Chapter 10 discusses how to work with third parties in your application. The key concept that I took away was never to export third party classes through your API. When you do this, you lose control. If the third party changes their API, then your API has changed without you doing anything. A change in a third party could even break your software, or your end-user’s implementation of your software.

Chapter 15: Evolving the API Universe

Chapter 15 introduces methods for changing an API without breaking backwards compatibility. This chapter also describes some tools and techniques that you can use to break compatibility, but to still provide your users with support for the old API by using libraries that provide bridges. Being able to provide new APIs that break backwards compatibility can be very powerful.

Comments

First, my complaints. They are pretty trivial for the most part.

I have to complain about the subtitle, “Confessions of a Java Framework Architect”. Confessions? A confession is “an admission of misdeeds or faults.” The author does describe a few mishaps from the NetBeans API, but I would hardly consider this a book of naughty confessions.

I also have to complain about some of the code examples, but I think this complaint is pretty common among software books with code. Sometimes, commonly accepted software development practices are ignored or left out for the sake of brevity and keeping the example small enough to fit on the page. One of the very first code examples comes on page 47 and in it (and throughout the book), Jaroslav hits us with a System.out.println. Wouldn’t this be like reading a web design book where all the examples used table-based layouts? Doesn’t everyone use some form of logging abstraction. I hate when books don’t follow best practices.

My last complaint is the first four chapters that make up Part 1 “Theory and Justification.” They are all theory are pretty boring. They are tough to get through when you know that if you just skipped a couple chapters you could be reading practical examples with code. There are a few good points and a few things that are good to know before you get to the practical part of the book, but I wish Jaroslav would just make the points and move on the Part 2 “Practical Design”.

I had a few complaints but they are mostly trivial. This truly was a good book. The best part is that the author, Jaroslav Tulach, is the founder of Netbeans and the leader of its API. He has dozens of great examples of good and bad API design from his experience with Netbeans. He describes situations where their API got out of control and how they dealt with it, methods for monitoring your API as a community or team with an API review, and how to avoid API mishaps. Jaroslav has also been around long enough and is so intimate with the evolution of the JDK that he is able to site specific examples in the JDK where changes to the API broke software around the world. Jaroslav is very knowledgeable on the topic and his writing shows it.

The book is full of practical examples. After reading many chapters, I went right to my open source project, Architecture Rules, and either changed code or emailed developer mailing list to suggest changes to code to encourage a better, more malleable and extensible API. I now realize how not only are my interfaces and methods part our API, but so are our file outputs and inputs. Even our exceptions messages are part of our API.

This is without a doubt a book that you need to put on your bookshelf. This is the first book of its kind and the tips and tricks that it provides is timeless - a key attribute of any pragmatic software development book. I encourage you to flip though this book at your local bookstore or just download Chapter 1:

Download the Excerpt

Bookpool.com offers this excerpt: Chapter 1: The Art of Building Modern Software.

Resources

• Purchase Practical API Design: Confessions of a Java Framework Architect
• Interview: Jaroslav Tulach, Author of “Practical API Design”
• Confessions of API Designers Blog
• http://blogs.apidesign.org