It might be stating the obvious that development is a rather fluid process. Few projects are ever “finished”, especially in businesses that are not inherently technical, but rely on technical process to en
able the business. As they use the product, and as business changes, the software must also adapt in kind. Aspects of the business may find new uses for the same software, but that adaptation will often incur a need for further development. Depending on how well organized the Development group is, this ongoing effort of development will have varying degrees of pain associated with it. Two well-developed processes in the industry endeavor to reduce this pain: continuous integration and unit testing.
Unit Testing takes the component-based architecture to heart and builds on the foundation that comes from. A component should be based on a concern of some sort. It may expect some input and, based on that input, it should exhibit some behavior or achieve some output. So, by this standard, you can establish a test that offers some specific input and test for the expected output. The test would be predicated on the requirement of the feature. When the code changes, and the requirement hasn’t, and the code passed the test before the change, if it fails after the change, you know something is wrong. If the requirement changes, and some will, then you change the test first, then you change the code to pass the test. This is much more like a “Ready, Aim, Shoot” response to challenge the normal “Ready, Shoot, Check the Target” effort that plagues a lot of companies.
Continuous Integration takes the effort of the unit testing one more step. Unit testing must be enforced each time the code changes, as soon as it has changed. One of the biggest problems in projects of all sizes and for maintenance efforts is that changes to code that eventually cause a break are harder to find the later they are found. If something got changed, but it wasn’t tested until a week or two later, and a number of other things got changed in the meantime, then it becomes a hunt to find the bug. But if you could find the results of the changed code immediately, then you would know exactly where the problem was.
This becomes a good bit more difficult in practice when you have a dozen developers all working within the same code, especially on a tight time schedule. The continuous integration effort utilizes a system that will scan for changes in a set area within the source code repository, and once a change is identified, it will automatically pull the entire project down, build, test, and report the results. It can be set to notify team members of the build results and processes can be built around these results to ensure everyone is informed of issues before they become nightmares. There are several systems of this type, some open source and some that can be purchased. Most of them are flexible on the repository and unit testing flavor, though some are specific to the programming technology, i.e. .Net rather than Java and vice versa. The gain out of all of this is a level of control over changes in a project that weigh a team down, reduce productivity, and tighten timelines even further.