 Build Management should be very straightforward and to the point, but like most IT subjects it is far from simple. To start off, build management is not the act of performing a build. That is simply building code from source files. The “management” of those builds by automating, scheduling, and accuracy of those builds is where the “management” side comes in. I will be covering the basics of build management in this article, nothing complex, just the basics.
Have a Good Build Process First
Before you do anything associated with a build you should have a good process mapped out as to the who, what, when, where, and how the build will be completed. Who is responsible for the build and the contact person for errors? What is actually being built and its dependencies, a CI list of what is expected and included in the build? When are the builds to be done? Where are the builds going to be deployed? How many different builds are we going to do? Once these factors are known, the process should be documented thoroughly and then you can begin the steps of automating your build procedure. Having a good process before automation will result in fewer headaches down the road. Automation of bad processes only hastens the impending doom that will result.
Automate your Builds
This should go without saying. Anything that can be automated should result in less time to complete and reduce the number of errors that can occur. Build errors are costly in terms of lost labor hours and to your customers if they go undetected during the testing process. Simply automating the build is not enough, the automated process should also give you detailed log files about what has happened during the build and also when and where in the build any errors occurred. This brings up an interesting point; folks who normally do the builds manually sometimes fear that by automating the build they will no longer be needed. On the contrary, automation simply shifts the focus of how the build is completed; there will still be plenty of work to do keeping the automation and build scripts up to date and working. Very few automated actions are static, change is constant and builds are no exception to this rule.
Build Manually
This is actually a part of Build Automation. How, you may ask? While build automation is very important and necessary, so is being able to do the build manually. Someone actually told me that, “Before a build is automated there should be a good manual process for the build available.” Why is this important? What if something breaks in your automated build? What if the people who wrote the build scripts left your company, what if there is a change in a operating system, a patch or upgrade that breaks the automated build process? Part of build management is to be prepared for these types of failures, and it could take days to fix the automated build or even figure out what went wrong. This could result in testing, deployment and release delays and that is never a good thing. Someone needs to know how to build all of the applications that you are responsible for manually.
Continuous Integration
This can be defined as, “The practice of frequently integrating one's new or changed code with the existing code repository.” The theory behind this is that as code is checked in errors can be detected earlier in the process rather than later. This will help keep the cost of finding bugs down. Detecting bugs in production can be extremely costly and can be devastating to a company’s bottom line. So the concept is this, a developer checks their code in and is picked up in the next build as the builds are running continually, depending on your environment this can be 24 hours a day if you have multiple development sites or 8 hours in a smaller shop. This forces developers to test their code earlier and fix bugs before they get to user acceptance or production. It creates a mentality of my code has to work before I check it in. This, in theory, will cut down on rejects and code fixes before they get to far downstream.
Who is responsible for the Builds?
Historically this has fallen on the CM person. This topic has been debated multiple times on CM Crossroads as to whether CM is responsible for builds or not. I am not here to debate the validity of CM doing builds or not, but only to say who shouldn’t perform the builds automated or manual. One concept that has come out of Software Development Life Cycle models and standards is the concept of segregation of duties or separation of duties. This is paramount in build management. I say this with no reservation, people who develop code should never, ever, under any circumstance build code that is going to UAT or Production. This is not a question of trust or not, I believe most developers would do the right things, however, safeguards must be put in place that limits the risk that code could be changed without it being checked in which could result in damage to the environment and harmful to the customers. This also applies to the build manager; under no circumstances should they allow code to be built that has not been put in the build repository, period. With those two statements said, if there is a production issue this rule can be relaxed, however, after a production issue is fixed, the code change that was made should go back through the normal process as soon as possible to make sure other areas weren’t broke by the change(s).
Conclusion
Build Management is concerned with timing, content, scheduling and consistency of the many types of builds possible. This includes baselining the code the is included in the builds that go to testing. Making sure that all builds are timely and deployable is extremely important. In addition, build management is the first part of the greater deployment process which is make or break for some companies. Get this part wrong and your company can spend a lot of money chasing errors and issues when it should be deploying and releasing code. While I have only scratched the surface of builds, and at times this field is not that glorious and at the forefront of release fanfare, that does not reduce the importance of building and managing your code repository. On the contrary, it is one of the most important steps that validates the development and starts the release process in motion.
About the Author Joe Townsend has been working in the Configuration Management field for 12 years. He has worked for CNA Life Insurance, RCA, Boeing, UPS and in State Government. Joe has primarily worked with Serena tools, including PVCS Version Manager, Tracker, TeamTrack(Mashups) and Dimensions including support and training. Joe is also an administrator for WebFocus and supports Eclipse users. Joe is also responsible for building all of the applications at my current location which includes a desktop and web based client. In addition to this work Joe is also an avid gardener and history buff. He have studied history for over 25 years mainly concentrating in European History. Joe keeps busy with his wife and 4 children; a 4 year old, 3 year old, 22 month old and a 5 month old.
Trackback(0)
Comments 
Write comment
 |
TrackBack URI for this entry
Subscribe to this comment's feed
