Programming Groovy 2 – For the experienced Java developer seeking dynamic productivity – #programming #bookreview

Programming Groovy 2

Dynamic Productivity for the Java Developer

Venkat Subramaniam
(Pragmatic Bookshelf, paperback)


The programming language
Groovy has a bit of a checkered past. Before it reached Release 1 in early 2007, it was almost abandoned because of a series of development problems. But some dedicated developers reworked it, gave it new life, and helped it gain acceptance in a widening array of commercial projects. Release 2.0 became available last year, and you can download 2.1, with 2.2 in beta. Groovy is doing groovy now, thank you very much (and thank the Grails web application framework, too).

In his new book, which keys off of his 2008 Groovy 1 edition, Dr. Venkat Subramaniam  describes Groovy 2 as “lightweight, low-ceremony, dynamic, object-oriented, and runs on the JVM [the Java Virtual Machine].”

He notes: “Groovy is open sourced under the Apache License, version 2.0. It derives strength from various languages such as Smalltalk, Python, and Ruby, while retaining a syntax familiar to Java programmers. Groovy compiles into Java bytecode and extends the Java API and libraries. It runs on Java 1.5 and newer. For deployment, all we need is a Groovy Java archive (JAR) in addition to the regular Java stuff, and we’re all set.”

Groovy is not for coding beginners, nor is it a means to avoid learning Java. This book–well written and nicely illustrated with short code examples and screenshots–”is aimed at Java programmers who already know the JDK [Java Development Kit] well but are interested in learning the Groovy language and its dynamic capabilities,” Dr. Subramaniam says.

He has organized his 19-chapter, 333-page book into three major parts:

Part I: Beginning Groovy – Focuses on the fundamentals of the language but deliberately skips the basics of programming. The book, after all, is aimed at “experienced Java programmers.”

Part II: Using Groovy – Shows “how to use Groovy for everyday coding–working with XML, accessing databases, and working with multiple Java/Groovy classes and scripts….” Also delves into Groovy extensions and additions to the JDK.

Part III: “MOPping Groovy” – The odd title may conjure up a brief image of mopping up spilled gravy. But this part deals with “Groovy’s metaprogramming capabilities….” The coverage includes: (1) metaobject protocol (MOP); (2) “how to do AOP-like operations in Groovy” [AOP = “aspect-oriented programming”]; and (3) “dynamic method/property discovery and dispatching,” as well as Groovy’s “compile-time metaprogramming capability….”

If you are a Java developer seeking new tools. new challenges, and new horizons, this could be the right time and right way to get your groove on: with Groovy 2 and Dr. Venkat Subramaniam’s fine how-to guide.

“Groovy is an attractive language for a number of reasons,” the author says, naming four key ones:

“It has a flat learning curve.”

“It follows Java semantics.”

“It bestows dynamic love.”

“It extends the JDK.”

“Groovy,” he adds, “feels like the Java language we already know, with a few augmentations.”

Si Dunn

Arquillian Testing Guide – For better integration testing & functional testing on the JVM – #programming #bookreview

Arquillian Testing Guide
John D. Ament
(Packt Publishing – Paperback, Kindle)

If you have some experience with integration testing and functional testing on a Java virtual machine (JVM), John D. Ament’s important new book can help you get up to speed with the Arquillian testing platform’s numerous features and capabilities.

Arquillian “leverages JUnit and TestNG to execute test cases against a Java container,” Ament explains. The Arquillian framework, he adds, has three major sections: “test runners (JUnit or TestNG), containers (Weld, OpenWebBeans, Tomcat, GlassFish, and so on), and test enrichers (integration of your test case into the container that your code is running in.)” Also: “ShrinkWrap is an external dependency for you to use with Arquillian; they are almost sibling projects. ShrinkWrap helps you define your deployments, and your descriptors to be loaded to the Java container you are testing against.”

Ament’s 224-page book shows how to write simple code for various Java application tests but also explains how to develop rich test cases that you can run automatically.

The author uses the JUnit test container in his examples but explains how you can use the TestNG test container, if you prefer.

While the book is aimed at readers with intermediate experience, newcomers to Java testing can learn from it, too. Before diving into the process of explaining Arquillian, Ament describes “the fundamentals of a test case,” from an Arquillian perspective, of course. And he devotes a chapter to “The Evolution of Testing,” from the early days of manually testing single units to the advent of automated testing with powerful new tools. (Manual testing, by the way, is still important and will not go away soon, Ament indicates. “There is likely no removing manual testing for functional applications,” he writes.

“Manual testing should be considered when performing user acceptance testing, where you need to validate that the application functions the way you would expect end to end. From a quality assurance standpoint, it’s the most direct way to make sure an application works the way expected.” But, he warns, “a developer shouldn’t wait until this point to begin testing….”

He also devotes a chapter to the basics and the process of container testing. “Arquilian is all about testing your code inside a container,” he says. “Containers represent what your application will run on.” His text examines each of the “three primary ways that Arquillian can interact with a container — embedded, managed, and remote.”

Embedded containers, he notes, “typically run on the same JVM as your test case. Next are managed containers, which Arquillian will start up for you during the test process and shut down after the tests are run but run in a different JVM. Finally, there are remote containers, which are assumed to be running prior to the test and will simply have deployments sent and tests executed.”

The book’s remaining chapters take the reader deeper into the testing processes and how to use of Arquillian’s features and extensions.

Arquillian is not software you can learn to use effectively in a single weekend of hacking. You must learn it by using it and using it a lot, Ament emphasizes. “Run as many tests as you can with Arquillian…[y]ou make the best use of Arquillian when you use it throughout 100 percent of your tests.”

Arquillian Testing Guide is available through several sources, including Amazon and Packt Publishing.

Si Dunn

Book Brief – Programming Grails – A new, solid guide for experienced developers – #programming #bookreview

Programming Grails
Burt Beckwith
(O’Reilly – paperback, Kindle )

Burt Beckwith is an experienced core developer on the Grails software team at SpringSource. His new book, Programming Grails, is written primarily for experienced Grails developers “who want to dig deeper into the architecture and understand more about how Grails works its magic and how it integrates with Groovy, Spring, Hibernate, and other technologies.”

Beckwith adds that “[d]evelopers with experience in similar frameworks such as Spring MVC, JEE, or Ruby on Rails should find this book useful in understanding how Grails implements features to which they are accustomed.”

He cautions that Programming Grails “should not be your first Grails book, since it presumes a good deal of previous experience and understanding, so be sure to read a more comprehensive Grails book first.”

The 12-chapter, 344-page book focuses on the inner workings of the Grails 2.0 feature set and emphasizes “best practices for building and deploying Grails applications,” including topics such as “performance, security, scaling, tuning, debugging, and monitoring.” It is written clearly, and its text is kept reasonably short between topic headings. Numerous short code samples and other illustrations are included.

Grails’ creator, Graeme Rocher, has given this book a solid thumb’s up, stating that “it goes much deeper than any other Grails book I have seen.”

Deploying with JRuby: Deliver Scalable Web Apps Using the JVM – It’s the simpler & better solution? – #bookreview

Deploying with JRuby: Deliver Scalable Web Apps Using the JVM
Joe Kutner
(Pragmatic Bookshelf, paperback)

Many developers are using Ruby on Rails to create web applications. But the supporting infrastructure often can be complex. And when a problem occurs, there is no centralized management interface to help you quickly determine what has gone awry.

There is a simpler and better solution, says JRuby specialist Joe Kutner in his new book. “The recent growth and increased adoption of the Java Virtual Machine (JVM) as a platform for Ruby applications has opened many new doors. Deployment strategies that were not possible with MRI [Matz’s Ruby Interpreter] Ruby are now an option because of the JVM’s built-in management tools and support for native operating system threads. Ruby programmers can leverage these features by deploying their applications on JRuby.”

Kutner’s 199-page book focuses on how the JVM can offer deployment choices that are “much better options than both Ruby and Java programmers are used to.” He describes “the most popular and well-supported for deploying JRuby. There is,” Kutner says, “a surprising amount of flexibility in the processes and platforms that can be used, which allows Ruby and Java programmers to tailor their deployments to suit many different environments.”

Deploying with JRuby has 10 chapters:

  • Getting Started with JRuby
  • Creating a Deployment Environment
  • Deploying an Archive File
  • Creating a Trinidad Application
  • Deploying a Trinidad Application
  • Creating a TorqueBox Application
  • Deploying a TorqueBox Application
  • Clustering a TorqueBox Application
  • Managing a JRuby Deployment
  • Using a Continuous Integration Server

Kutner points out that production JRuby environments have “fewer moving parts than traditional Ruby environments. This is possible because of the JVM’s support for native operating system threads. Instead of managing dozens of processes, JRuby can use multiple threads of execution to do work in parallel. MRI has threads, but only one thread can execute Ruby code at a time. This has led to some complex workarounds to achieve concurrency.”

His book is written smoothly and to the point, and there are numerous illustrations and procedure steps. He also offers a “no-Java-code promise,” stating: “You will not have to write any Java code as you work your way through this book….The technologies and tools that you will be introduced to in this book hide the XML and Java code from you.”

Still, you are free to include Java code or make calls to Java libraries, if you want to, he adds. Or you may, as many others do, choose to write programs “exclusively in Ruby and deploy them on the Java Virtual Machine….There are many reasons,” Joe Kutner says, “to deploy Ruby applications on the JVM, and using Java libraries and APIs is just one of them.”

Si Dunn