views:

166

answers:

7

I am attempting to convince my colleagues to start using a build server and automated building for our Silverlight application. I have justified it on the grounds that we will catch integration errors more quickly, and will also always have a working dev copy of the system with the latest changes. But some still don't get it.

What are the most significant advantages of using a Build Server for your project?

+3  A: 

See Continuous Integration: Benefits of Continuous Integration :

On the whole I think the greatest and most wide ranging benefit of Continuous Integration is reduced risk. My mind still floats back to that early software project I mentioned in my first paragraph. There they were at the end (they hoped) of a long project, yet with no real idea of how long it would be before they were done.

...

As a result projects with Continuous Integration tend to have dramatically less bugs, both in production and in process. However I should stress that the degree of this benefit is directly tied to how good your test suite is. You should find that it's not too difficult to build a test suite that makes a noticeable difference. Usually, however, it takes a while before a team really gets to the low level of bugs that they have the potential to reach. Getting there means constantly working on and improving your tests.

If you have continuous integration, it removes one of the biggest barriers to frequent deployment. Frequent deployment is valuable because it allows your users to get new features more rapidly, to give more rapid feedback on those features, and generally become more collaborative in the development cycle. This helps break down the barriers between customers and development - barriers which I believe are the biggest barriers to successful software development.

From my personal experience, setting up a build server and implementing CI process, really changes the way the project is conducted. The act of producing a build becomes an uneventful everyday thing, because you literally do it every day. This allows you to catch things earlier and be more agile.

Also note that setting build server is only a part of the CI process, which includes setting up tests and ultimately automating the deployment (very useful).

Another side-effect benefit that often doen't get mentioned is that CI tools like CruiseControl.NET becomes the central issuer of all version numbers for all branches, including internal RCs. You could then enforce your team to always ship a build that came out of the CI tool, even if it's a custom version of the product.

eed3si9n
+11  A: 

There are more advantages than just finding compiler errors earlier (which is significant):

  • Produce a full clean build for each check-in (or daily or however it's configured)
  • Produce consistent builds that are less likely to have just worked due to left-over artifacts from a previous build
  • Provide a history of which change actually broke a build
  • Provide a good mechanism for automating other related processes (like deploy to test computers)
Sam
+5  A: 
  • Continuous integration reveals any problems in the big picture, as different teams/developers work in different parts of the code/application/system
  • Unit and integration tests ran with the each build go even deeper and expose problems that would maybe not be seen on the developer's workstation
  • Free coffees/candy/beer. When someone breaks the build, he/she makes it up for the other team members...

I think if you can convince your team members that there WILL be errors and integration problems that are not exposed during the development time, that should be enough.

And of course, you can tell them that the team will look ancient in the modern world if you don't run continuous builds :)

fish
+2  A: 

Early warning of broken or incompatible code means that all conflicts are identified asap, thereby avoiding last minute chaos on the release date.

Eric Eijkelenboom
+1  A: 
  • When your boss says "I need a copy of the latest code ASAP" you can get it to them in < 5 minutes.

  • You can make the build available to internal testers easily, and when they report a bug they can easily tell you "it was the April 01 nightly build" so that you can work with the same version of the source code.

  • You'll be sure that you have an automated way to build the code that doesn't rely on libraries / environment variables / scripts / etc. that are set up in developers' environments but hard to replicate by others who want to work with the code.

Harold L
+1  A: 

We have found the automatic VCS tagging of the exact code that produce a version very helpful in going back to a specific version to replicate an issue.

David Sykes
+1  A: 

Integration is a blind spot
Integration often doesn't get any respect - "we just throw the binaries into an installer thingie". If ithis doesn't work, it's the installers fault.

Stable Build Environment
Prevents excuses such as "This error sometimes occurs when built on Joe's machine". Prevents using old dependent libraries accidentally when building on Mikes machine.

True dogfooding
You inhouse testers and users have a true customer experience. Your developers have a clear reference for reproducing errors.

peterchen