Continuous Integration

Continuous Integration

Definitions of Continuous Integration?

Continuous integration (CI) is the practice, in software engineering, of merging all developer working copies with a shared mainline several times a day.

CI is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early.

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly.

A mechanism that rebuilds your project whenever a check in is made into some revision control system (CVS etc). This can be extended though to include running tests, all the way through to generating a CD image, mounting it within VMs, installing the product and running full tests on it.

It is the practice of ensuring that all aspects of your software development process are lined up to permit the daily creation of a working version of your product. It is best known as part of Extreme Programming.

CI is a new paradigm to handle different kinds of integration problems:

• Merge conflicts

• Compile conflicts

• Test conflicts

Details of Continuous Integration

It was first named and proposed as part of extreme programming (XP). Its main aim is to prevent integration problems, referred to as "integration hell" in early descriptions of XP. CI can be seen as an intensification of practices of periodic integration advocated by earlier published methods of incremental and iterative software development, such as the Booch method.

The Booch method is a technique used in software engineering. It is an object modeling language and methodology that was widely used in object-oriented analysis and design. The notation aspect of the Booch method has now been superseded by the Unified Modeling Language (UML), which features graphical elements from the Booch method along with elements from the object-modeling technique (OMT) and object-oriented software engineering (OOSE).

CI was originally intended to be used in combination with automated unit tests written through the practices of test-driven development. Initially this was conceived of as running all unit tests and verifying they all passed before committing to the mainline. This helps avoid one developer's work in progress breaking another developer's copy. If necessary, partially complete features can be disabled before committing using feature toggles.

Feature Toggle, (also Feature Switch, Feature Flag, Feature Flipper, Conditional Feature, etc.) is a technique in software development that attempts to provide an alternative to maintaining multiple source code branches, called feature branches. Continuous release and continuous deployment enables you to have quick feedback about your coding. This requires you to integrate your changes as early as possible. Feature branches introduce a by-pass to this process. Feature toggles brings you back to the track, but the execution paths of your feature is still "dead" and "untested", if a toggle is "off". But the effort is low to enable the new execution paths just by setting a toggle to "on". Continuous release and continuous deployment enables you to have quick feedback about your coding. This requires you to integrate your changes as early as possible. Feature branches introduce a by-pass to this process. Feature toggles brings you back to the track, but the execution paths of your feature is still "dead" and "untested", if a toggle is "off". But the effort is low to enable the new execution paths just by setting a toggle to "on".

In addition to automated unit tests, organisations using CI typically use a build server to implement continuous processes of applying quality control in general — small pieces of effort, applied frequently. In addition to running the unit and integration tests, such processes run additional static and dynamic tests, measure and profile performance, extract and format documentation from the source code and facilitate manual QA processes. This continuous application of quality control aims to improve the quality of software, and to reduce the time taken to deliver it, by replacing the traditional practice of applying quality control after completing all development. This is very similar to the original idea of integrating more frequently to make integration easier, only applied to QA processes.

Quality Assurance (QA) is a way of preventing mistakes or defects in manufactured products and avoiding problems when delivering solutions or services to customers. QA is applied to physical products in pre-production to verify what will be made meets specifications and requirements, and during manufacturing production runs by validating lot samples meet specified quality controls. QA is also applied to software to verify that features and functionality meet business objectives, and that code is relatively bug free prior to shipping or releasing new software products and versions.

Continuous integration – the practice of frequently integrating one's new or changed code with the existing code repository – should occur frequently enough that no intervening window remains between commit and build, and such that no errors can arise without developers noticing them and correcting them immediately. Normal practice is to trigger these builds by every commit to a repository, rather than a periodically scheduled build. The practicalities of doing this in a multi-developer environment of rapid commits are such that it's usual to trigger a short time after each commit, then to start a build when either this timer expires, or after a rather longer interval since the last build. Many automated tools offer this scheduling automatically.

How do Continuous Integration Tools Work?

•    Runs as a server

•    Connect to your SVN every minute

•    Checks to see if any changes have been commited

•    Check out changes

•    Build the system

•    Run Testing tools (JUnit, PMD, Checkstyle, FindBugs, etc...)

•    Email failures to your project team

Benefits of Continuous Integration

•    Say goodbye to long and tense integrations

•    Increase visibility which enables greater communication

•    Catch issues fast and nip them in the bud

•    Spend less time debugging and more time adding features

•    Proceed in the confidence you’re building on a solid foundation

•    Stop waiting to find out if your code’s going to work

•    Reduce integration problems allowing you to deliver software more rapidly


Continuous Integration
added 5 years 7 months ago

Contents related to 'Continuous Integration'

CruiseControl and CruiseControl.Net (CCNet): CruiseControl is both a continuous integration tool and an extensible framework for creating a custom continuous build process.

TeamCity: TeamCity is a closed source, Java-based build management and continuous integration server from JetBrains.

Jenkins: Jenkins provides continuous integration services for software development. It is a server-based system running in a servlet container such as Apache Tomcat.

- IPython
- Bootstrap
- Apache Pig
- Apache Cassandra
- Jenkins
- Nginx Server
- Continuous Integration
- Threading Building Blocks (TBB)
- Message Passing Interface (MPI)
- Language-Integrated Query (Linq)
- Maven
- Element Management System (EMS)
- Asynchronous JavaScript and XML (AJAX)
- Transport Layer Security (TLS), Secure Sockets Layer (SSL)
- GlassFish
- Virtual Destinations
- Stomp
- Process Templates
- Apache Portable Runtime (Apr)
- Java Message Service (JMS)
5
4
3
2
1