Books & Videos

Table of Contents

  1. Build Tools

    1. Chapter 1 Setting Up a Project Using Ant

      1. Ant in the Build Process
      2. Installing Ant
      3. A Gentle Introduction to Ant
      4. Compiling Your Java Code in Ant
      5. Customizing Your Build Script Using Properties
      6. Running Unit Tests in Ant
      7. Generating Documentation with Javadoc
      8. Packaging Your Application
      9. Deploying Your Application
      10. Bootstrapping Your Build Scripts
      11. Using Maven Dependencies in Ant with the Maven Tasks
      12. Using Ant in Eclipse
      13. Using Ant in NetBeans
      14. Manipulating XML with XMLTask
      15. Conclusion
    2. Chapter 2 Setting Up a Project Using Maven 2

      1. Maven and the Development Build Process
      2. Maven and Ant
      3. Installing Maven
      4. Declarative Builds and the Maven Project Object Model
      5. Understanding the Maven 2 Lifecycle
      6. The Maven Directory Structure
      7. Configuring Maven to Your Environment
      8. Dependency Management in Maven 2
      9. Looking for Dependencies with MvnRepository
      10. Project Inheritance and Aggregation
      11. Creating a Project Template with Archetypes
      12. Compiling Code
      13. Testing Your Code
      14. Packaging and Deploying Your Application
      15. Deploying an Application Using Cargo
      16. Using Maven in Eclipse
      17. Using Maven in NetBeans
      18. Using Plug-Ins to Customize the Build Process
      19. Setting Up an Enterprise Repository with Archiva
      20. Setting Up an Enterprise Repository Using Artifactory
      21. Using Ant in Maven
      22. Advanced Archetypes
      23. Using Assemblies
  2. Version Control Tools

    1. Chapter 3 Setting Up Version Control Using CVS

      1. An Introduction to CVS
      2. Setting Up a CVS Repository
      3. Creating a New Project in CVS
      4. Checking Out a Project
      5. Working with Your Files—Updating and Committing
      6. Resolving a Locked Repository
      7. Working with Keyword Substitution
      8. Working with Binary Files
      9. Tags in CVS
      10. Creating Branches in CVS
      11. Merging Changes from a Branch
      12. Viewing Change History
      13. Reverting Changes
      14. Using CVS in Windows
    2. Chapter 4 Setting Up Version Control Using Subversion

      1. An Introduction to Subversion
      2. Installing Subversion
      3. Subversion Repository Types
      4. Setting Up a Subversion Repository
      5. Setting Up a New Subversion Project
      6. Checking Out Your Working Copy
      7. Importing Existing Files into Subversion
      8. Understanding Subversion Repository URLs
      9. Working with Your Files
      10. Seeing Where You’re At: The Status Command
      11. Resolving Conflicts
      12. Using Tags, Branches, and Merges
      13. Rolling Back to a Previous Revision
      14. Using File Locking with Binary Files
      15. Breaking and Stealing Locks
      16. Making Locked Files Read-Only with the svn:needs-lock Property
      17. Using Properties
      18. Change History in Subversion: Logging and Blaming
      19. Setting Up a Subversion Server with svnserve
      20. Setting Up a Secure svnserve Server
      21. Setting Up a WebDAV/DeltaV Enabled Subversion Server
      22. Setting Up a Secure WebDAV/DeltaV Server
      23. Customizing Subversion with Hook Scripts
      24. Installing Subversion As a Windows Service
      25. Backing Up and Restoring a Subversion Repository
      26. Using Subversion in Eclipse
      27. Using Subversion in NetBeans
      28. Using Subversion in Windows
      29. Defect Tracking and Change Control
      30. Using Subversion in Ant
      31. Conclusion
  3. Continuous Integration

    1. Chapter 5 Setting Up a Continuous Integration Server with Continuum

      1. An Introduction to Continuum
      2. Installing a Continuum Server
      3. Manually Starting and Stopping the Server
      4. Checking the Status of the Server
      5. Running the Continuum Server in Verbose Mode
      6. Adding a Project Group
      7. Adding a Maven Project
      8. Adding an Ant Project
      9. Adding a Shell Project
      10. Managing Your Project Builds
      11. Managing Users
      12. Setting Up Notifiers
      13. Configuring and Scheduling Builds
      14. Debugging Your Builds
      15. Configuring the Continuum Mail Server
      16. Configuring the Continuum Web Site Ports
      17. Automatically Generating a Maven Site with Continuum
      18. Configuring a Manual Build Task
      19. Conclusion
    2. Chapter 6 Setting Up a Continuous Integration Server with CruiseControl

      1. An Introduction to CruiseControl
      2. Installing CruiseControl
      3. Configuring an Ant Project
      4. Keeping People Notified with Publishers
      5. Setting Up a Maven 2 Project in CruiseControl
      6. The CruiseControl Dashboard
      7. Third-Party Tools
      8. Conclusion
    3. Chapter 7 LuntBuild—A Web-Based Continuous Integration Server

      1. An Introduction to LuntBuild
      2. Installing LuntBuild
      3. Configuring the LuntBuild Server
      4. Adding a Project
      5. Using Project Variables for Version Numbering
      6. Build Results Diagnostics
      7. Using LuntBuild with Eclipse
      8. Reporting on Test Coverage in Luntbuild Using Cobertura
      9. Integrating Luntbuild with Maven
      10. Conclusion
    4. Chapter 8 Continuous Integration with Hudson

      1. An Introduction to Hudson
      2. Installing Hudson
      3. Managing the Hudson Home Directory
      4. Installing Upgrades
      5. Configuring Hudson
      6. Adding a New Build Job
      7. Organizing Your Jobs
      8. Monitoring Your Builds
      9. Viewing and Promoting a Particular Build
      10. Managing Users
      11. Authentication and Security
      12. Viewing Changes
      13. Hudson Plug-Ins
      14. Keeping Track of Test Results
      15. Keeping Track of Code Metrics
      16. Reporting on Code Coverage
    5. Chapter 9 Setting Up an Instant Messaging Platform with Openfire

      1. Instant Messaging in a Development Project
      2. Installing Openfire
      3. Setting Up Users and Accounts on Openfire
      4. Authenticating Users in an External Database
      5. Authenticating Users Against a POP3 Server
      6. Virtual Team Meetings with the Group Chat
      7. Extended Functionality with Openfire Plug-Ins
      8. Using Openfire with Continuum
      9. Using Openfire with CruiseControl
      10. Using Openfire with Luntbuild
      11. Sending Jabber Messages from a Java Application Using the Smack API
      12. Detecting Presence Using the Smack API
      13. Receiving Messages Using the Smack API
  4. Unit Testing

    1. Chapter 10 Testing Your Code with JUnit

      1. JUnit 3.8 and JUnit 4
      2. Unit Testing with JUnit 4
      3. Setting Up and Optimizing Your Unit Test Cases
      4. Simple Performance Testing Using Timeouts
      5. Checking for Exceptions the Easy Way
      6. Using Parameterized Tests
      7. Using assertThat and the Hamcrest Library
      8. JUnit 4 Theories
      9. Using JUnit 4 with Maven 2
      10. Using JUnit 4 with Ant
      11. Selectively Running JUnit 4 Tests in Ant
      12. Integration Tests
      13. Using JUnit 4 in Eclipse
    2. Chapter 11 Next-Generation Testing with TestNG

      1. Introducing TestNG
      2. Creating Simple Unit Tests with TestNG
      3. Defining TestNG Test Suites
      4. The TestNG Eclipse Plug-In
      5. Using TestNG in Ant
      6. Using TestNG with Maven 2
      7. Managing the Test Lifecycle
      8. Using Test Groups
      9. Managing Dependencies
      10. Parallel Testing
      11. Test Parameters and Data-Driven Testing
      12. Checking for Exceptions
      13. Handling Partial Failures
      14. Rerunning Failed Tests
    3. Chapter 12 Maximizing Test Coverage with Cobertura

      1. Test Coverage
      2. Running Cobertura from Ant
      3. Checking the Code Coverage of TestNG Tests
      4. Interpreting the Cobertura Report
      5. Enforcing High Code Coverage
      6. Generating Cobertura Reports in Maven
      7. Integrating Coverage Tests into the Maven Build Process
      8. Code Coverage in Eclipse
      9. Conclusion
  5. Integration, Functional, Load, and Performance Testing

    1. Chapter 13 Testing a Struts Application with StrutsTestCase

      1. Introduction
      2. Testing a Struts Application
      3. Introducing StrutsTestCase
      4. Mock Tests Using StrutsTestCase
      5. Testing Struts Error Handling
      6. Customizing the Test Environment
      7. First-Level Performance Testing
      8. Conclusion
    2. Chapter 14 Integration Testing Databases with DbUnitContributed by John Hurst

      1. Introduction
      2. Overview
      3. DbUnit Structure
      4. Example Application
      5. Priming the Database
      6. Verifying the Database
      7. Replacing Values
      8. Alternative Dataset Formats
      9. Dealing with Custom Data Types
      10. Other Applications
    3. Chapter 15 Performance Testing with JUnitPerf

      1. Introducing JUnitPerf
      2. Measuring Performance with TimedTests
      3. SimulatingLoad with LoadTests
      4. Load-Testing Tests That Are Not Thread-Safe
      5. Separating Performance Tests from Unit Tests in Ant
      6. Separating Performance Tests from Unit Tests in Maven
    4. Chapter 16 Load and Performance Testing with JMeter

      1. Introduction
      2. Installing JMeter
      3. Testing a Simple Web Application
      4. Structuring Your Test Case
      5. Recording and Displaying Test Results
      6. Using the JMeter Proxy to Record a Test Case
      7. Testing Using Variables
      8. Testing on Multiple Machines
    5. Chapter 17 Testing Web Services with SoapUI

      1. Introduction
      2. An Introduction to SoapUI
      3. Installing SoapUI
      4. Installing a Local Web Service
      5. Testing Web Services with SoapUI
      6. Load-Testing with SoapUI
      7. Running SoapUI from the Command Line
      8. Running SoapUI from Ant
      9. Running SoapUI from Maven
      10. Continuous Testing
      11. Conclusion
    6. Chapter 18 Profiling and Monitoring Java Applications Using the Sun JDK Tools

      1. The Sun JDK Profiling and Monitoring Tools
      2. Connecting To and Monitoring a Java Application with jConsole
      3. Monitoring a Remote Tomcat Application with jConsole
      4. Detecting and Identifying Memory Leaks with the JDK Tools
      5. Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat
      6. Detecting Deadlocks
    7. Chapter 19 Profiling Java Applications in Eclipse

      1. Profiling Applications from Within an IDE
      2. The Eclipse Test & Performance Tools Platform
      3. Installing TPTP
      4. TPTP and Java 6
      5. Basic Profiling with TPTP
      6. Studying Memory Use with the Basic Memory Analysis Results
      7. Analyzing Execution Time
      8. Displaying Coverage Statistics
      9. Using Filters to Refine Your Results
      10. Profiling a Web Application
      11. Conclusion
    8. Chapter 20 Testing Your User Interfaces

      1. Introduction
      2. Testing Your Web Application with Selenium
      3. Testing Swing GUIs with FEST
      4. Conclusion
  6. Quality Metrics Tools

    1. Chapter 21 Detecting and Enforcing Coding Standards with CheckstyleSome of the material in this chapter appeared in it’s first incarnation on on the 29th of March 2006, in the article “Maintain Better Coding Standards with Ease Using Checkstyle”

      1. Using Checkstyle to Enforce Coding Standards
      2. Using Checkstyle in Eclipse
      3. Customizing Checkstyle Rules in Eclipse
      4. Customizing Checkstyle Rules Using the XML Configuration Files
      5. Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use
      6. Defining Rules for Source Code Headers with Checkstyle
      7. Suppressing Checkstyle Tests
      8. Using Checkstyle with Ant
      9. Using Checkstyle with Maven
    2. Chapter 22 Preemptive Error Detection with PMDSome of the material in this chapter appeared in it’s first incarnation on on the 20th of April 2006, in the article “PMD Squashes Code Bugs”

      1. PMD and Static Code Analysis
      2. Using PMD in Eclipse
      3. Configuring PMD Rules in Eclipse
      4. More on the PMD Rulesets
      5. Writing Your Own PMD Ruleset
      6. Generating a PMD Report in Eclipse
      7. Suppressing PMD Rules
      8. Detecting Cut-and-Paste with CPD
      9. Using PMD in Ant
      10. Using PMD in Maven
    3. Chapter 23 Preemptive Error Detection with FindBugs

      1. FindBugs: A Specialized Bug Killer
      2. Using FindBugs in Eclipse
      3. Selectively Suppressing Rules with FindBug Filters
      4. Using FindBugs Annotations
      5. Using FindBugs in Ant
      6. Using FindBugs in Maven
      7. Conclusion
    4. Chapter 24 Inspecting the Results—Semiautomated Code Review with JupiterThis work was originally published on the DevX website on June 8, 2006, under the title “Peer Code Reviews Made Easy with Eclipse Plug-In”.

      1. Introducing Jupiter—A Code Review Tool for Eclipse
      2. Installing Jupiter in Eclipse
      3. Understanding the Jupiter Code Review Process
      4. Conducting Personal Code Reviews
      5. Configuration
      6. Setting Up Default Configuration Values
      7. Individual Reviews
      8. Team Review
      9. Rework Phase
      10. Jupiter Behind the Scenes
      11. Conclusion
    5. Chapter 25 Sharpen Your Focus with Mylyn

      1. Introduction to Mylyn
      2. Installing Mylyn
      3. Tracking Tasks and Issues
      4. Interacting with Task Repositories
      5. Focusing on a Task with Context Management
      6. Using the Eclipse Change Sets
      7. Sharing Context with Other Developers
      8. Conclusion
    6. Chapter 26 Monitoring Build Statistics

      1. Introduction
      2. QALab
      3. Source Code Management Metrics with StatSCM
      4. Statistics in Ant with StatSVN
  7. Issue Management Tools

    1. Chapter 27 Bugzilla

      1. An Introduction to Bugzilla
      2. Installing Bugzilla
      3. Setting Up Your Bugzilla Environment
      4. Managing User Accounts
      5. Restricting Access Using User Groups
      6. Configuring a Product
      7. Tracking Progress with Milestones
      8. Managing Groups of Products with Classifications
      9. Searching for Bugs
      10. Creating a New Bug
      11. The Lifecycle of a Bugzilla Bug
      12. Scheduling Notifications (Whining)
      13. Customizing Fields in Bugzilla
      14. Conclusion
    2. Chapter 28 Trac—Lightweight Project Management

      1. An Introduction to Trac
      2. Installing Trac
      3. Setting Up a Trac Project
      4. Running Trac on the Standalone Server
      5. Setting Up Tracd As a Windows Service
      6. Installing Trac on an Apache Server
      7. Administrating the Trac Site
      8. Managing User Accounts
      9. Tailoring the Trac Web Site: Using the Wiki Function
      10. Using the Trac Ticket Management System
      11. Updating Trac Issues from Subversion
      12. Customizing Trac Ticket Fields
      13. Setting Up Email Notifications
      14. Reporting Using Trac Queries and Reports
      15. Managing Progress with Trac Roadmaps and Timelines
      16. Browsing the Source Code Repository
      17. Using RSS and ICalendar
      18. Customizing a Wiki Page with Python
      19. Conclusion
  8. Technical Documentation Tools

    1. Chapter 29 Team Communication with the Maven 2 Project Web SiteSome of the material in this chapter was originally published on JavaWorld in the article “Get the most out of Maven 2 site generation” (

      1. The Maven 2 Project Web Site As a Communication Tool
      2. Setting Up a Maven Site Project
      3. Integrating Reports into Your Site
      4. Creating a Dedicated Maven Site Project
      5. Defining the Site Outline
      6. The Maven Site Generation Architecture
      7. Using Snippets
      8. Customizing the Look and Feel of Your Site
      9. Distributing Your Site
    2. Chapter 30 Automatically Generating Technical Documentation

      1. Introduction
      2. Visualizing a Database Structure with SchemaSpy
      3. Generating Source Code Documentation with Doxygen
      4. Embedding UML Diagrams in Your Javadoc with UmlGraph
      5. Conclusion
  1. Bibliography

  2. Colophon