Continuous Integration

Skip to end of metadata
Go to start of metadata

Continuous Integration (CI) is a practice in software development describing the process of regular, comprehensive and automatic building and testing of applications. CI is often used in agile projects, but not limited to them. Traditionally the process is based on the following main steps:

  1. A developer did changes and enhancements on the application and wants to merge them to the main trunk so others can see and work with them too.
  2. He runs all tests.
  3. He does an update to retrieve the recent changes from the central repository merging them to the local workspace.
  4. He runs all tests.
  5. If the tests go through successfully he commits the changes to the central version control system.
  6. A build server takes the artifacts and creates a build normally containing compiling code, testing and packaging.
  7. The build server communicates defects to the developers e.g. failed tests.

There are some issues with this traditional approach. Basically, defects will be detected pretty late especially after the sources are already in the version control system. Additionally in a regular approach there is often the problem that developers do not feel responsible for a broken build, they do not know where exactly the bug is, the build server administration is difficult and not efficient, the code is of suboptimal quality and the build results are not promoted well. TeamCity finds solutions for those daily issues.

Advantage of CI include

  • Integration problems are detected and made visible continuously.
  • Permanent testing of the software.
  • The application is always deliverable.
  • The stakeholders (e.g. the customer) can always view a runnable version of the software.

Further links:
http://martinfowler.com/articles/continuousIntegration.html
http://jetbrains.com/teamcity
http://www.jetbrains.net/confluence/display/ADMY/Pre-tested+Commit

Labels:
None
Enter labels to add to this page:
Please wait 
Looking for a label? Just start typing.