This book is divided into four parts. Part 1 gives an overview of Agile ALM and sets the stage for parts 2 through 4. Part 2 deals with the functional aspects of ALM, including functional release management and task-based development. Part 3 discusses integration management and releasing, and includes dependency management and technical releasing with Maven, productive development environments and tools, and additional recipes for continuous integration. Part 4 explains my view of outside-in development for barrier-free development and testing.
In addition, the book contains many examples. Chapter 1 gives pragmatic explanations and a field report from Siemens, where ALM is used. Subsequent chapters deliver details and numerous examples that implement the principles presented in the first chapter.
Here’s a more detailed outline of the material we will be exploring.
In part 1, I provide the basics of what Agile ALM is, including its benefits and features. I also talk about Agile in general. Chapter 1 sets the stage and gives you a feel for what Agile ALM is. Chapter 2 introduces Agile including the message of the Agile manifesto and how it relates to ALM, and discusses Agile strategies (such as continuous integration). All the other chapters discuss and implement the building blocks illustrated in chapters 1 and 2.
In part 2, we’ll focus on the functional, high-level part of ALM. Chapter 3 details how to implement the general management template called Scrum and how to bridge Scrum to more traditional environments. It also provides strategies and tools for supporting the functional release of software. Examples of supporting vehicles are version-control hooks and release calendars.
Scrum can be thought of as an easy, compact, abstract framework. Although I also explain Scrum at a high level, I focus on the details of how to implement Scrum in real life. This is rarely covered elsewhere. Most books on Scrum are too high level to help you learn the essentials for successfully implementing these excellent Agile practices. Finally, chapter 4 discusses task-based development, illustrating two toolchains (including how you can orchestrate them freely). The first is based on JIRA, Bamboo, Mylyn, and FishEye, and the second is based on Trac. Although Trac is quite useful on its own, it can be combined with tools like Mylyn or Hudson/Jenkins. This chapter gives an overview of these tools.
With part 3, we leave the functional, high-level features of ALM and dive into its more technical aspects. This part is about integration management and the technical aspects of releasing software. As I’ll explain, ALM is about iteratively integrating artifacts, building and testing them, and providing software releases that are high quality and free of defects. Maven is one of the market leaders in providing a comprehensive lifecycle and release process. In chapter 5, we’ll discuss some of Maven’s important features, especially dependency management and how it helps to host component repositories in different flavors. Here, I’ll also show how you can use Maven in traditional environments without rolling out a full-fledged repository manager. We’ll discuss Artifactory as one of the major full-fledged repository managers. Finally, we’ll go through a complex real-world releasing process showing Maven in action. As you can see, all these topics provide valuable, advanced, best practices. Maven is a major backbone for the rest of the book. Subsequent chapters use or discuss Maven in some form.
Chapter 6 deals with productive development environments. Major topics include strategies and tools for enabling congruent builds as part of an advanced “workspace management” environment, as well as methods for integrating and working with artifacts on developers’ desktops. Other facets of this chapter cover Mockito (for mocking), Cargo, TeamCity (for remote runs), and Maven’s archetype feature. All these concepts and tools can help improve the productivity of development environments.
Chapter 7 delivers tools and recipes for advanced continuous integration. We’ll review the basics, and then dive into advanced scenarios, including strategies and tools for continuous integration. The first section of this chapter covers concepts and tools for integrating languages that have suboptimal native build management integration (we’ll look specifically at Cobol). Afterward, we’ll look at how to integrate Microsoft .NET artifacts. You’ll see that you don’t need to buy Microsoft products to integrate .NET apps continuously and that you can use TeamCity (or Hudson/Jenkins) and Subversion to build and store assets. This also helps to unify the toolchain while integrating many different languages and platforms.
Another section of chapter 7 is about configuration and staging, which can be a big challenge in software projects. We’ll discuss how to configure an application for different target environments without rebuilding the software and how to deploy Maven modules in an automatic, consistent way. We’ll also talk about feature branching with Subversion and Git (to show how to bridge two VCS technologies) and discuss two popular continuous integration servers. The first is Hudson/Jenkins. You’ll see how to use it for building software, auditing (together with Sonar), and staging Maven artifacts. The second is TeamCity, and we’ll discuss .NET integration and demonstrate how easy it is to incorporate the use of cloud computing.
The last part of the book is about “outside-in development” as well as collaborative and barrier-free development and testing. Chapter 8 looks at an Agile ALM approach to requirements management and test management. Here, you’ll learn about collaborative tests (where users, customers, testers, and developers work hand in hand), and we’ll go through many advanced scenarios and toolchains. Starting with a basic data-driven infrastructure, we’ll optimize the solution by managing data with XStream and Excel, to the point of writing acceptance tests. Further sections provide other views and possible solutions, using Fit and FitNesse. We’ll also use GivWenZen for behavior-driven development (BDD).
Chapter 9 discusses polyglot platforms and the details of collaborative and barrier-free development. Here, we’ll discuss Groovy and BDD with Scala and specs2. I’ll show the potential of barrier-free development using Java, Scala, and Groovy.
This book contains advanced strategies and real-world scenarios for using Agile ALM tools. It’s targeted to advanced users, but motivated beginners will also benefit. If you’re a beginner, I’ll lead you through the Agile ALM cosmos, teaching you about Agile ALM and providing brief explanations on how to get started with the various tools I’ll discuss. If you aren’t familiar with a particular tool (or a concept) yet, you’ll get all the necessary introduction, along with pointers to further resources.
From a project management perspective, this book is for developers, testers, development leads, technical project managers, (technical) release managers, and all IT people who want to improve the development process. People with Java skills, especially those who already use or plan to use the tools introduced here, will benefit the most from this book.
The book will be most useful for the IT professional who wants to become familiar with Agile ALM, as well as for future users of the tools seeking advice for advanced use and best practices of applying Agile strategies.
The most up-to-date source code for the book can be found here: http://huettermann.net/alm/. Code and tools that are mentioned in this book have different hardware and software requirements. Please consult the how-tos inside the downloadable source code, the respective sections in the book, and the resources for the specific tools for further details. The source code is also available from the publisher’s website at www.manning.com/AgileALM.
The publisher and author have taken great care in the preparation of this book, but we make no expressed or implied warranty for the code and text due to any errors or omissions that might be contained in the book, in spite of our best efforts. An errata list will be posted on the publisher’s website after publication and updated for as long as the book is in print.
It was a long journey to decide on the final book title. My first ideas for the title included terms like “configuration management” or “open source ALM.” But neither of these was quite right. ALM is more than configuration management—although it is based on the discipline called software configuration management. In addition, while this book covers the best-of-breed lightweight tools, not all of them are open source.
The final title, Agile ALM, along with the subtitle, Lightweight Tools and Agile Strategies, best expresses the message of this book. It covers Agile strategies and lightweight tools through the complete software application lifecycle. What the title also suggests and the book explains in detail is that software development is not a unidirectional “fire and forget” activity. Rather, software development is done in cyclic loops, with iterations and increments, across all project phases, from requirements engineering to delivery, gaining feedback from users who work with the delivered software, to again start the loop.
When I submitted the manuscript to Manning in March 2010, the term “Agile ALM” was rarely used in the IT scene. Now, after the early access version of this book has been available for over a year, the expression “Agile ALM” is widespread. But the term is often used without a clear understanding of what Agile ALM really means. This book delivers a definition of Agile ALM and puts together the requirements that tools should implement in order to label themselves “Agile ALM” tools. Today, many tool vendors describe their products with words like “Agile,” or “ALM,” or both, to indicate that the tool supports application lifecycle management in an agile way.
In this book, “Agile ALM” is used only in an editorial sense with no intent to infringe on any trademark.
This book will not teach you all the tools from scratch nor all facets of these tools. For instance, if you’re new to Maven (which, as noted earlier, is a backbone for Agile ALM), you should consider consulting a dedicated resource on that tool, such as one of the many books on Maven that explain the tool from scratch. I also don’t explain all strategies and concepts at every step. For instance, if you’re interested in Scrum, you may want to consult books dedicated to Scrum. This book isn’t meant to include detailed end-to-end descriptions of tools that are already discussed in other books dedicated to those subjects.
You probably will not use all the tools discussed in this book. Maybe you already use some of them, or you may prefer other tools. It’s not possible to cover all the available tools in these pages, but the tools that are covered here are (or are likely to become) de facto standards, and most are already in widespread use. The individual choice of tools will depend on local conditions, personal preferences, and how your team operates. One could make arguments for or against each category of tool presented in this book, as well as for or against the tools I chose to cover, depending on context. From an Agile perspective, we want to find the “sweet spot” where we have all the tools we need for local conditions, and nothing more.
What’s true for tools is also true for platforms and languages. This book is based on Java, although many examples show how to bridge to other platforms and languages. As with tools, it’s not possible to cover all available platforms and languages.
Although most of the tools discussed in the book are open source and freely available, some tools are commercial, and worth the investment. Examples of commercial tools are the excellent products from Atlassian, such as JIRA and Bamboo, which you can use for setting up a task-based development toolchain, and TeamCity, which I discuss for running remote builds.
This book doesn’t provide comparisons of tools. I take a different approach—instead of being tool-centric, I take a use case–driven approach. I show how to implement all major aspects of Agile ALM with specific tools, similar to a cookbook. In most cases, I discuss only one tool, but sometimes I use more than one in conjunction, or I integrate one with others. In all cases, I focus on best-of-breed solutions or toolchains for rolling out Agile ALM, but there are always other options you could use.
Purchase of Agile ALM includes free access to a private web forum run by Manning Publications where you can make comments about the book, ask technical questions, and receive help from the author and from other users. To access the forum and subscribe to it, point your web browser to www.manning.com/AgileALM. This page provides information on how to get on the forum once you are registered, what kind of help is available, and the rules of conduct on the forum.
Manning’s commitment to our readers is to provide a venue where a meaningful dialog between individual readers and between readers and the author can take place. It is not a commitment to any specific amount of participation on the part of the author, whose contribution to the book’s forum remains voluntary (and unpaid). We suggest you try asking him some challenging questions lest his interest stray!
The Author Online forum and the archives of previous discussions will be accessible from the publisher’s website as long as the book is in print.
A Java Champion, Michael Hüttermann (SCJA, SCJP, SCJD, SCWCD), is a freelance developer, architect, coach, author, and tutor for Java/JEE, ALM/SCM, and agile software development. He speaks at international conferences and was the responsible stage producer of the tooling track of Agile 2009. He is the founder and driver of the Java User Group Cologne, a java.net JUGs Community Leader, a member of Agile Alliance, on the board of the JetBrains Academy, a committer to FEST, and a Java contributor. Michael has written numerous articles and two German books: Agile Java-Entwicklung in der Praxis (O’Reilly, 2008), and Fragile Agile (Hanser, 2010).
Further information about the author, including ways to contact him, can be found at http://huettermann.net.
