Tuesday, October 23, 2012

Review: "Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications" by Mick Knutson


This has been in the inbox for far too long. I apologize for not being able to bring this out more timely but beside my "night-job" I also do have a day-job and a family. But this post shouldn't be about complaining but about a new book. Packt shipped it in June this year and I was curious what it will look like. The title is promising an here is my review.

Abstract
This book covers exciting recipes on securing, tuning, and extending Enterprise Applications using a Java EE 6 implementation. The book starts with the essential changes in Java EE 6. Then we will dive into the implementation of some of the new features of the JPA 2.0 specification, and look at implementing auditing for relational data stores. There are several additional sections that describe some of the subtle issues encountered, tips, and extension points for starting your own JPA application, or extending an existing application.
We will then look into how we can enable security for our software system using Java EE built-in features as well as using the well-known Spring Security framework. We will then look at recipes on testing various Java EE technologies including JPA, EJB, JSF, and web services.
Next we will explore various ways to extend a Java EE environment with the use of additional dynamic languages as well as frameworks. The book then covers recipes that touch on the issues, considerations, and options related to extending enterprise development efforts into mobile application development. At the end of the book, we will cover managing Enterprise Application deployment and configuration, and recipes that will help you debug problems and enhance the performance
of your applications.

Book: Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications
Language : English
Paperback : 356 pages [ 9.2 x 7.6 x 0.9 inches ]
Release Date : June 25, 2012
ISBN-10: 1849683166
ISBN-13: 978-1849683166

About the Author
Mick Knutson (@mickknutson) has nearly two decades of experience working in the IT industry in various roles as Enterprise technology consultant, Java Architect, project leader, Engineer, Designer and Developer and he gained a wide variety of experience in disciplines including Java EE, Web Services, Mobile Computing and Enterprise Integration Solutions. He has also is a frequent conference speaker, does trainings and seminars, publishes white papers and books. Find his blog at http://www.baselogic.com/blog/

The Content
The book has 356 pages. If you take away all the preface and index stuff you end up with roughly 300 pages of content and examples. That is a good number.

Chapter 1 gives a high-level summary of the key changes in the Java EE 6 release. The focus is directed on how these new features will simplify your development, as well as how to improve your application performance.
Chapter 2 covers persistence. In this chapter, we will dive into the implementation of some of the new features of the JPA 2.0 specification, and look at implementing auditing for relational data stores. There are also several additional sections that describe some typical issues encountered, further tips, and extension points for starting your own JPA application, or extending an existing application.
Chapter 3 dives into Security. It looks at the Java EE built-in features as well as into the well-known Spring
Security framework, which is a widely accepted framework for more fine-grained security implementations.
Chapter 4 covers testing strategies: It includes testing-related recipes for testing various Java EE technologies, including JPA, EJB, JSF, and web services.
Chapter 5 finally is about extending your applications. It explore various ways to extend a Java EE environment with the use of additional dynamic languages as well as frameworks (Groovy, Scala, AspectJ).
Chapter 6 calls on mobile device integration. It looks into mobile application development frameworks, talks about native app considerations, testing and environments.
Chapter 7 covers deployment and configuration. It dives into issues and solutions to application configuration. Covering standard Java EE APIs to access external properties files, as well as Groovy-based configuration scripts. Advanced configuration topics include Java Management Extensions (JMX).
Chapter 8 tells you about performance and debugging. It describes the basics needed for understanding performance-related issues in a Java EE application and ways to identify the cause. Performance topics that will be covered include profiling application memory, TCP connections, server sockets, and threading-related problems. It also covers tools and how to extend their capabilities (Netstat, TCPMon, Munin).

Writing and Style
I am probably the worst case reviewer. I'm struggling with my own not native English and try to find good examples to improve my own skills. Measured with that in mind I must say that it wasn't the easiest book I have read. And I don't feel like I could use it as a good example for my own skills. The writing is very precise but the formatting with the "How to do it ..." sections and the many source-code lines in-between makes reading and following harder than it should be. Further on text and lists are cluttered with screenshots, drawings and diagrams. Especially the class diagrams are very fine grained and I was happy to have the digital edition to zoom in. Couldn't compare how the printed version looks like but might be too small. I'm glad there is no list of figures. It would have added another 10 pages to the book. Overall it mostly felt like a transcript of a screen cast.

Conclusion and recommendation
I'm very split here. I first thought this might be a good general introduction. But this isn't always the case. The JPA chapter for example starts with introducing you to the new 2.0 features. So beginners don't get a hint where to start. It simply builds on what you should already know about Java EE 5. I assume that someone who already has a decent background here would be able to use a profiler and install it to an ide without screenshots.
The book mostly covers GlassFish and Tomcat and gives many many examples in both code and visuals. If you are looking for some more comprehensive dictionary this might be the wrong book for you. Even if the title is appealing and stressing the word "Enterprise" it doesn't really cover "Enterprise grade" topics but Java Enterprise Edition applications. This could lead you into the wrong direction if you are buying your books by the title. If you feel like you are missing the link between theory and practice and you believe you need to measure your knowledge, give it a try. It might be the right book for you. I wouldn't recommend it to beginners.