Deployment Approaches for the AgitarOne Product Family
The AgitarOne product family helps you work safer, better, and smarter as you develop and maintain your Java applications. AgitarOne JUnit Generator helps you find regressions when you change existing code and creates the foundation for safely improving your code to reduce your maintenance costs. AgitarOne Agitator helps you prevent complexity and avoid bugs in new code. AgitarOne is the best way to create, use, and manage the unit-level tests needed for extremely agile development. There is a specific AgitarOne deployment approach ideally suited for the problems facing your organization.
One of the common problems facing software projects is that while the developers understand the new code well, they must also deal with a large body of legacy code that they don't understand and for which they don’t have tests. As this code is changed, it is easy to introduce subtle bugs. These bugs are often not detected until much later in the project cycle – and sometimes are found only by users of the released application. These bugs are a common cause of delays in meeting schedules because developers don't fully understand the impact of their changes and lack tools that can give them that insight.
Because the biggest pain point for most software teams is the cost and risk of maintaining and enhancing their legacy Java applications, our recommended best practice for using AgitarOne is to tackle the legacy code first, then address new code creation. Teams already adept at unit testing and not facing the burden of legacy applications can start with Improve New Code Creation (see below).
Work Safer – Generate a Safety Net
Use AgitarOne JUnit Generator to generate automatically a safety net of thorough JUnit tests – averaging 80%+ coverage out-of-the-box on most code – that documents the current behavior of the application. This safety net makes it easier to see the impact of code changes, which makes changing the code much less risky. This safety net can be generated with little or no involvement from the development staff. The generated tests are checked in and run at desired intervals using AgitarOne's continuous integration and testing support. Test failures are analyzed and developers are notified when they have broken something (and introduced a regression). This approach brings immediate benefits with minimal effort.
Work Better – Actively Improve Existing/Legacy Code
AgitarOne JUnit Generator creates a thorough test suite that enables a small "SWAT Team" of QA personnel, an architect, or a few lead developers to greatly improve the code, improving the business agility of the entire development organization. The high out-of-the-box coverage provides the necessary foundation for safe code changes. You can limit these changes to the identification and elimination of common problems, such as unhandled exceptions. You can go further and refactor the code; refactoring takes work but it is the best way to reduce the complexity and ongoing cost of the code. Any of this work can be done on an as-needed basis, focused on the most important and/or fragile parts of the code as they are about to be modified. As this work results in less fragile code, the overall team will spend much less time on legacy maintenance and enhancement. This frees staff for new applications and to start to simplify and improve other applications. This process will also serve as an example to the enterprise of what is possible when a comprehensive agile development and unit test strategy is in place and begins to show benefits, which makes it much easier to focus on proactive testing by developers as they create new code.
Work Smarter – Improve New Code Creation
Developers interactively use AgitarOne Agitator as they create new code or extensively modify their code. Agitator provides valuable insights into the actual behavior of the code and provides a way for developers to validate behaviors (class- or method-level invariants) that they expect of the code. AgitarOne Agitator helps developers to prevent complexity and minimize bugs so today's new code does not become tomorrow's fragile legacy code. Teams can also use AgitarOne JUnit Generator on the new code to complement hand-written JUnit tests, providing much more thorough coverage than is practical with purely hand-written tests, with much less effort.
Improve Visibility and Management Oversight
The three approaches described above can be used separately or combined into one continuous agile process on legacy code and new projects. The complexity, coverage, and risk associated with any given project or projects roll up into an overall dashboard report to management. This report provides real-time visibility where it did not exist, before and provides the ability to make good decisions during code construction, instead of waiting to discover problems in a QA review, system test, or production release meeting.