Publications

Books
“Continuous Integration: Improving Software Quality and Reducing Risk” (Paul Duvall, Stephen M. Matyas, Andrew Glover, Addison-Wesley, July 2007) “Groovy in Action” (Dierk Koenig, Andrew Glover, Paul King, Guillaume Laforge, Jon Skeet, Manning, January 2007)
“No Fluff Just Stuff Anthology” (Neal Ford, et al. Pragmatic Bookshelf, June 2006) “Java Testing Patterns” (Jon Thomas, Matthew Young, Kyle Brown, Andrew Glover, Wiley, October 2004)
Articles
  • “Build a RESTful Web service” (DeveloperWorks, July 2008) - REST is a way of thinking, not a protocol or standard. It’s a style of designing loosely coupled applications– more often than not, applications oriented for the Web — that rely on named resources rather than messages. In this tutorial, you’ll get to know what REST is and how to build RESTful applications with Restlets, a lightweight REST framework for Java applications.
  • “Build software with Gant” (DeveloperWorks, May 2008) - Gant is a highly versatile build framework that leverages both Groovy and Ant to let you implement programmatic logic while using all of Ant’s capabilities. In this tutorial, you’ll learn how to define behavior in your build through Gant’s flexible domain-specific language, how to reuse Ant features, and how to define functions that make your builds more efficient and even proactive.
  • “Fluently Groovy” (DeveloperWorks, March 2008) - Get started with Groovy. Learn about Groovy’s syntax and productivity features, like native collections, built-in regular expressions, and closures. Write your first Groovy class, and test it using JUnit and pure Java code.
  • “ The future is now — Java development in 2008” (JavaWorld, January 2008) - 2007 was full of exciting plot twists, punctuated by growing excitement about dynamic languages, the open source evolution of the JVM, and the rise of Google as a strategic contributor to the Java community. The question is, what does all that tell us about what’s coming in 2008?
  • DeveloperWorks In pursuit of code quality series
    • “Spot defects early with Continuous Integration” (November 2007) - This tutorial guides you step-by-step through the fundamental concepts of Continuous Integration using Hudson, Ant, and Subversion. When you’re done, you’ll understand the benefits of Continuous Integration as well as how to set up and properly configure Hudson, Ant, and Subversion to work together. The resulting build process will run both tests and software inspections and will report back violations almost as quickly as they occur.
    • “Adventures in behavior-driven development” (September 2007) - Test-driven development is a great idea in practice, but some developers just can’t get over the conceptual leap associated with that word test. In this article, learn about a more natural way to integrate the momentum of TDD into your programming practice.
    • “Unit testing Ajax applications” (July 2007) - You might get a thrill out of writing Ajax applications, but unit testing them is surely painful. This article takes on the downside of Ajax (one of them, anyway), which is the inherent challenge of unit testing asynchronous Web applications.
    • “Beware the tight couple!” (May 2007) - You know tight coupling is bad news and you really want to avoid it in your designs — but the question is how. In this article, learn how to recognize a tightly coupled system and then disentangle it using the Dependency Inversion Principle.
    • “Programmatic testing with Selenium and TestNG” (March 2007) - This article shows you how to run Selenium tests programmatically, using TestNG as the test driver. Once you’ve added TestNG’s flexible testing features (including parametric fixtures) to Selenium’s native toolkit, all you need is a little help from DbUnit and Cargo to write fully automated, logically repeatable acceptance tests.
    • “Automate GUI testing with TestNG-Abbot” (Feb 2007) - This article walks you through the hardest part of GUI testing with TestNG-Abbot, which is understanding how a user scenario will play out. Once you’ve got that down, you’ll find it surprisingly easy to isolate GUI components and then verify them using the framework’s handy fixture objects.
    • “Jump into JUnit 4” (Feb 2007) - This tutorial shows you how to leverage the new features in JUnit 4 enabled by annotations, including parametric tests, exception tests, and timed tests.
    • “Defensive programming with AOP” (Jan 2007) - This article shows you an easier way to add reusable validation constraints to your code using the power of AOP, design by contract, and a handy library called OVal.
    • “Discover XMLUnit” (Dec 2006) - Developers are natural problem solvers, so it makes sense that someone has come up with an easier way to validate XML documents. This article introduces XMLUnit, a JUnit extension framework that meets all your XML validation needs.
    • “Performance testing with JUnitPerf” (Nov 2006) - Performance testing is usually left for last in the application development cycle — not because it’s unimportant, but because it’s hard to test effectively with so many unknown variables. This article makes the case for performance testing as part of the development cycle and shows you two easy ways to do it.
    • “Use test categorization for agile builds” (Oct 2006) - Everyone agrees that developer testing is important, but why is it so darn time consuming to run tests? This article reveals the three categories of testing needed to ensure end-to-end system soundness and then shows you how to automatically sort and run tests by category. The result is a dramatically reduced built time, even with today’s massive test suites.
    • “Repeatable system tests” (Sep 2006) - Writing logically repeatable tests is especially tricky when testing Web applications that incorporate a servlet container. This article introduces Cargo, an open source framework that automates container management in a generic fashion, so you can write logically repeatable system tests every time.
    • “JUnit 4 vs. TestNG” (Aug 2006) - With its new, annotations-based framework, JUnit 4 has embraced some of the best features of TestNG, but does that mean it’s rendered TestNG obsolete? This article considers what’s unique about each framework and reveals three high-level testing features you’ll still find only in TestNG.
    • “Testing Struts legacy apps” (Jul 2006) - Even as Struts does a slow fade into the Web Framework Hall of Fame, its legacy lives on, mostly in the form of applications that need to be tested and maintained. This article shows you how to put the quality-centered approach to the test (so to speak) on Struts, using JUnit’s StrutsTestCase and DbUnit.
    • “Tame the chatterbox” (Jun 2006) - Learn three important ways to measure code complexity, based on method length, class length, and intra-class coupling.
    • “Refactoring with code metrics” (May 2006) - This article shows you how to use those same metrics and the Extract Method pattern for targeted refactoring.
    • “Code quality for software architects” (Apr 2006) - This article shows how to continuously monitor and correct quality aspects of code that can affect the long-term viability of your software architecture.
    • “Monitoring cyclomatic complexity” (Mar 2006) - If complexity has been shown to correlate to defects, doesn’t it make sense to monitor your code base’s complexity values?
    • “Resolve to get FIT” (Feb 2006 ) - Find out how the Framework for Integrated Tests facilitates communication between the business clients who write requirements and the developers who implement them.
    • “Don’t be fooled by the coverage report” (Jan 2006) - This article takes a closer look at what the numbers on the coverage report really mean, as well as what they don’t.
  • “Much ado about Boo” (InfoQ, March 2007) - Take a look at boo, which is a Python inspired language targeting the .NET CLI that enables rapid development of compliant Windows applications. With boo, you can quickly write developer tests, build GUIs, prototype applications– you name it– this language is frighteningly simple, man.
  • “Test Categorization Techniques with TestNG” (Dev2Dev, Nov 2006) - This article examines the concept of test categories and demonstrates how to incorporate TestNG’s groups annotation tied with flexible fixtures to facilitate running tests at different frequencies via specific Ant targets.
  • “Ruby off the Rails” (DeveloperWorks, Dec 2005) - This article digs beneath the hype of Ruby on Rails for a look at what Java developers can do with Ruby, all by itself.
  • DeveloperWorks Practically Groovy series
    • “Smooth operators” (Oct 2005) - The Java language has banned operator overloading, but Groovy says “bring it on!” Find out about Groovy’s three categories of overloadable operators
    • “Of MOPs and mini-languages” (Sep 2005) - Put your ear to the ground and listen closely — MOP is on the move! Get a primer on the Meta Object Protocol, an old-is-new approach to building applications, languages, and applications as languages.
    • “Functional programming with curried closures” (Aug 2005) - Spice up your standard closures with the curry method, invented by Haskell Curry and found in the Groovy language since before the JSR compliant releases.
    • “Groovy’s growth spurt” (Jul 2005) - With the release (and subsequent releases) of a JSR-241 compliant parser, the changes to Groovy’s syntax have been formalized — which means if you weren’t paying attention before, now’s the time to start. This article walks through most important changes to Groovy’s syntax and shows you a handy feature you won’t find in classic Groovy.
    • “Stir some Groovy into your Java apps” (May 2005) - Ever thought about embedding Groovy’s simple, easy-to-write scripts in your more complex Java programs? This article shows you the many ways to incorporate Groovy into your Java code and explains where and when it’s appropriate to do so.
    • “Mark it up with Groovy Builders” (Apr 2005) - Groovy Builders let you mimic markup languages like XML, HTML, Ant tasks, and even GUIs with frameworks like Swing. They’re especially useful for rapid prototyping and, as this article shows you, they’re a handy alternative to data binding frameworks when you need consumable markup in a snap!
    • “Go server side up, with Groovy” (Mar 2005) - The Groovlet and GroovyServer Pages (GSP) frameworks are built on the shoulders of the Java Servlet API. Unlike Struts and JSF, however, Groovy’s server-side implementation isn’t meant for all occasions. Rather, it’s a simplified alternative for developing server-side applications quickly and easily.
    • “MVC programming with Groovy templates” (Feb 2005) - This article shows how Groovy’s template engine framework can simplify view programming and make your code more maintainable over time.
    • “JDBC programming with Groovy” (Jan 2005) - GroovySql combines closures and iterators to ease Java Database Connectivity (JDBC) programming by shifting the burden of resource management from you to the Groovy framework itself.
    • “Ant scripting with Groovy” (Dec 2004) - This article introduces Groovy’s builder utility, which makes it especially easy to combine Groovy with Ant and Maven for more expressive and controllable builds.
    • “Unit test your Java code faster with Groovy” (Nov 2004) - This article introduces a simple strategy for unit testing Java code with Groovy and JUnit.
  • DeveloperWorks alt.lang.jre series
    • “Twice as Nice” (Oct 2004) - Nice is a JRE compatible, object-oriented language that brings tremendous expressiveness to the Java platform. Nice also lets you implement many of the cutting edge features found in Java 5 on any Java virtual machine.
    • “Feeling Groovy” (Aug 2004) - This article offers an informal introduction to Groovy, the proposed addition to the standard programming languages for the Java platform.
  • “AOP banishes the tight-coupling blues” (DeveloperWorks, Feb 2004) - In this article, you’ll see for yourself how one of AOP’s functional design concepts — static crosscutting — can turn what might be a tangled mass of tightly coupled code into a powerful, extensible enterprise application.
  • “Python-Powered Templates with Cheetah” (OnLamp, Jan 2005) - If you use Python, consider instead Cheetah, a template engine based on Python. This article demonstrates its simplicity and power for producing text in all kinds of formats.
  • “Code Improvement Through Cyclomatic Complexity” (OnJava, Jun 2004) - Overly complex code is dangerous, hard to maintain if not already buggy. But what do we mean by “complex”? The metric of cyclomatic complexity helps show where the most complex code is. As this article illustrates, finding the complex code is also the first step to refactoring
  • “Effective Unit Testing with DbUnit” (OnJava, Jan 2004) - Writing unit tests first can be impractical when your code will depend on access to a database. Enter DbUnit, which allows you to write simple XML files to fill in for the yet-to-be populated database for testing purposes.

Andy

Comments are closed.

Trackback this Post |