Review: Release it!

This is a review of the book “Release it!” by Michael T. Nygard

Go get this book. That is the short of this review. This is an excellent book, mainly targeted towards architects however I think developers should read it too. The author does an great job throughout the book showing how small issues can grow into gigantic problems and cost your project/business some big $$$, when in reality, had the developer or architect paid a bit more attention to certain pieces of the application, it all could have been avoided. The author shares many of his personal experiences related to this subject.

The two best parts of the book where the coverage of stability issues (patterns and anti-patterns), and the capacity planning section. The final two main sections of the book cover general design issues and operations (monitoring, logging, metrics etc).

Recommended: Yes
Skill levels: Any

Local IO write performance in Zinc improved

Looks like the folks over at MDM have improved their local IO write support (windows only) with the release of v3.0.10 of MDM Zinc. This is probably due to Adobe AIR and people’s complaints about the lack of better support for writing ByteArray data to disk in Zinc. Note that this new feature is only available when you are running on a PC
(mac/linux still have to use the old HEX conversion method)

In a previous post I wrote about the slow performance of writing binary data in Zinc. However now it is definitely faster, however still not as fast as writing under Adobe AIR. Regardless, it looks like MDM has listened to their users and made a step to improve things and that is great.

Here is an example of how to write a ByteArray to disk now under 3.0.10. Note this is faster than the old HEX conversion method and is much faster and less code:

var data:ByteArray = // some byte array of your data
mdm.FileSystem.BinaryFile.setDataBA(data);
mdm.FileSystem.BinaryFile.writeDataBA("c:\some\path\to\file");

Kudos to the folks at MDM for adding this new feature.

Review: Interface Oriented Design

This is a review of “Interface Oriented Design” by Ken Pugh.

I don’t have a ton to say about this book, it was a fairly quick read at about 200 pages. If you have a lot of experience with OO, the concepts presented within it are nothing that startling, however they may serve the reader as a nice refresher or presentation of important principles in a “interface” oriented and focused approach. I think if anything, one handy thing that the author presented were the “laws” of any interface:

a) “Do what its methods say it does” : this is obviously important as how many times have you seen methods in a program that do what their name implies, but… sometimes add on a bit more undocumented functionality.

b) “Do no harm”: the implementation to should avoid affecting other modules or consuming resources that it does not explicitly declare it will etc.

c) “Provide meaningful errors”: I think this is often missing. Too many times I’ve called some method to get a horrible low-level exception thrown back at me, or a custom one with some un-intelligible error code. Rarely wil you get back something meaningful, like the author suggests which contains not only the problem, but why it occurred and how you can possibly avoid it on the next call.

Overall I found chapters 1-7 to be the most informative, while chapters 8-10 went through some examples which focused on the principles covered in 1-7 in working examples. Chapter 11 covers the standard GoF patterns but from a “interface” based perspective.

Overall, I would say that if you are pretty versed in OO you could get a way with skipping this book. Otherwise if you are intermediate or new to OO and the proper use of interfaces as opposed to constantly using inheritance, this might be a good book for you.

Lastly I will say that after reading this book, when faced with new design decisions, I found myself focusing much, much more on pure interface based designs and minimizing inheritance except where absolutely necessary.

Revew: The Definitive Guide to Terracotta

This is a review for the book “The Definitive Guide to Terracotta” by Terracotta, Inc.

For several years I had known about Terracotta when the software was still closed source, and generally did not give it a look. Once Terracotta became open source my interest rose and I wanted to give it a look over to determine if it could be used as a possible solution for an application which currently could only scale vertically. So, I bought this book and began reading.

The whole concept of Terracotta is that from a developer perspective you just code Java. You create in memory caches, use synchronized blocks, threads, blocks, waits etc without worrying about clustering issues because Terracotta is essentially JVM clustering with network attached memory. This concept and idea is appealing because Terracotta can give you the tools to take an older Java application and essentially make it cluster ready, without major modifications to the code as it works today; full transparency; at least that is the idea. Basically you analyze your application code and identify the parts (class members etc) which need to be shared across the clustered JVM and instrumented by Terracotta, you do this with some XML configuration.

That is the super short of it. With regards to the book; well frankly this book is excellent. Being written by the architects at Terracotta themselves, you are getting a first hand HOW TO to get up and running with this amazing peice of software. The book starts out with the high level concepts of what clustering is, the issues with it, how Terracotta helps, and then they jump you right in to a working HelloWorld example that you can get running easily and see how this all works. The rest of the book takes you through all of the features such as how to use it with Hibernate, Spring, HTTP sessions, pojos, caching etc. Towards the end they even touch on grid computing and threads.

I absolutely recommend this book for anyone who is seriously interested in evaluating if Terracotta would work for you as it is great to have it all in one book, vs. reading online via multiple resources.

Recommended? YES
Skill Level? Advanced/Java