Last week, I was asked to give my opinion on Application Lifecycle Management or ALM. Specifically, I was asked how can teams effectively manage their design, development, test and deploy processes as well as pick the right tools for the job. Here is the answer I gave:
The cornerstone of a strong ALM process is based in Agile (opens in a new tab) practices and principles (opens in a new tab). Iterative software development is useful for breaking work up into small chunks that provides fast and frequent feedback to both the team and the customer. Developing software using test driven development (opens in a new tab) (with an emphasis on behavior driven development (opens in a new tab)) allows developers to focus on behavior first as well as quality. Developers will iteratively evolve the design (opens in a new tab) of the software based on the tests, and will limit the amount of up front design. Automated tests are executed as part of an automated build process that is in turn executed by a continuous integration (opens in a new tab) server monitoring version control. Developers should be checking in their changes frequently, triggering multiple builds, resulting in multiple feedback cycles. All development should take place on the trunk in version control and branching should be limited.
Taking ALM a step further lies the continuous delivery (opens in a new tab) practice of deployment pipelines (opens in a new tab). Like with standard continuous integration, each change to source triggers a new build on the CI server. With deployment pipelines, you are chaining together a series of builds, each responsible for validating a certain condition or set of conditions (like acceptance tests or coding style). Each build should expand on the previous with an increasingly rigorous criteria. The goal of deployment pipelines is validate a change to source to see if it is production worthy, i.e. a release candidate. In some environments, deployment pipelines are automated all the way to production (opens in a new tab), where a change from a developer can go to production without a single person touching it. To achieve this, automation and feedback are essential. Unit, Integration, Acceptance and Performance Tests must all be phases of the deployment pipelines with rigorous criteria to keep a build out of production that doesn't meet the standard. Managing code is also an essential part of the pipeline, which is achieved using static code analysis tools. In addition, automating the deployment of the application from source to the Dev, Test, Staging and Production is also an essential practice.
In regards to tools to enable this process, it is hard to come up with a list without assuming certain technologies and biases for/against open source. For the sake of this discussion, I will assume a Java application where open source is king. For version control, Subversion gets the job done, but distributed version control systems (git and mercurial) are extremely popular and gaining ground. For Agile project management, unless you are on a distributed team, I recommend sticking with cards and a scrumboard and avoid complex tools. For testing, there are a multitude of tools available, JUnit (opens in a new tab) being the core of the testing world. Mockito (opens in a new tab) is an excellent and simple mocking framework, but JMock (opens in a new tab) provides some valuable features not found in Mockito. Selenium (opens in a new tab) is a great web application testing tool (but avoid recording (opens in a new tab) and use page objects (opens in a new tab)), especially when coupled with a BDD framework like easyb (opens in a new tab) or JBehave (opens in a new tab). JMeter (opens in a new tab) is a great tool for performance testing. For build tools, I feel that Gradle (opens in a new tab) or Buildr (opens in a new tab) are better than Maven (opens in a new tab), which is better than Ant (opens in a new tab). Gradle/Buildr build on the legacy of Maven and Ant and improve on them in different ways. For continuous integration, I highly recommend using Hudson (opens in a new tab)/Jenkins (opens in a new tab) for most environments, but it lacks some of the advanced deployment pipeline features you can find in ThoughtWorks (opens in a new tab) Go (opens in a new tab) product (not FOSS (opens in a new tab)). For measuring code quality, I recommend Checkstyle (opens in a new tab), PMD/CPD (opens in a new tab), Findbugs (opens in a new tab), Crap4j (opens in a new tab) and Cobertura (opens in a new tab) for measuring code coverage. I also highly recommend Liquibase for database management and a tool like Puppet (opens in a new tab) or Chef (opens in a new tab) to manage your infrastructure. In addition, I also recommend using Nexus (opens in a new tab) as a binary repository for build artifacts produced in the pipeline.
My thoughts were somewhat off the cuff and could likely be more comprehensive given time, but I still found them valuable. I would to hear what you think of this answer and if you have differing opinions. Enjoy!