- Shopping Bag ( 0 items )
"Wow, what can I say? Chapter 4, 'The Build Lab and Personnel,' by itself is enough justification to purchase the book! Vince is obviously a 'Dirty Finger Nails' build meister and there is a lot we can all learn from how he got them dirty! There are so many gems of wisdom throughout this book it's hard to know where to start describing them! It starts where SCM should start, at the end, and works its way forward. This book is a perfect complement to the 'Follow the Files' approach to SCM that I espouse. I will recommend that every software lead and software configuration management person I work with be required to read this book!"
—Bob Ventimiglia, autonomic logistics software configuration manager, Lockheed Martin Aeronautics
"The Build Master contains some truly new information; most of the chapters discuss points that many people in the industry don't have a full understanding of and need to know. It's written in a way that is easy to read and will help a reader fill holes in their vision regarding software build management. I especially liked Vince's use of Microsoft stories to make his points throughout the book. I will purchase the book and make certain chapters mandatory reading for my build manager consultants."
—Steve Konieczka, SCM consultant
"Vince does a great job of providing the details of an actual working build process. It can be very useful for those who must tackle this task within their own organization. Also the 'Microsoft Notes' found throughout the book provide a very keen insight into the workings of Microsoft. This alone is worth purchasing this book."
—Mario E. Moreira, author of Software Configuration Management Implementation Roadmap and columnist at CM Crossroads
"Software configuration management professionals will find this book presents practical ideas for managing code throughout the software development and deployment lifecycles. Drawing on lessons learned, the author provides real-world examples and solutions to help you avoid the traps and pitfalls common in today's environments that require advanced and elegant software controls."
—Sean W. Sides, senior technical configuration manager, Great-West Healthcare Information Systems
"If you think compiling your application is a build process, then this book is for you. Vince gives us a real look at the build process. With his extensive experience in the area at Microsoft, a reader will get a look in at the Microsoft machine and also how a mature build process should work. This is a must read for anyone doing serious software development."
—Jon Box, Microsoft regional director, ProTech Systems Group
"Did you ever wonder how Microsoft manages to ship increasingly complex software? In The Build Master, specialist Vince Maraia provides an insider's look."
—Bernard Vander Beken, software developer, jawn.net
"This book offers an interesting look into how Microsoft manages internal development of large projects and provides excellent insight into the kinds of build/SCM things you can do for your large-scale projects."
—Lance Johnston, vice president of Software Development, SCM Labs, Inc.
"The Build Master provides an interesting insight into how large software systems are built at Microsoft covering the set up of their build labs and the current and future tools used. The sections on security, globalization, and versioning were quite helpful as these areas tend to be overlooked."
—Chris Brown, ThoughtWorks, consultant
"The Build Master is a great read. Managing builds is crucial to the profitable delivery of high-quality software. Until now, the build process has been one of the least-understood stages of the entire development lifecycle. This book helps you implement a smoother, faster, more effective build process and use it to deliver better software."
—Robert J. Shimonski, Networking and Security Expert, http://www.rsnetworks.net
The first best-practice, start-to-finish guide for the software build process
Managing builds is crucial to the profitable delivery of high-quality software; however, the build process has been one of the least-understood stages of the entire development lifecycle. Now, one of Microsoft's leading software build experts introduces step-by-step best practices for maximizing the reliability, effectiveness, timeliness, quality, and security of every build you create.
Drawing on his extensive experience working with Microsoft's enterprise and development customers, Vincent Maraia covers all facets of the build process—introducing techniques that will work on any platform, on projects of any size. Maraia places software builds in context, showing how they integrate with configuration management, setup, and even customer support. Coverage includes
Builds powerfully impact every software professional: developers, architects, managers, project leaders, configuration specialists, testers, and release managers. Whatever your role, this book will help you implement a smoother, faster, more effective build process—and use it to deliver better software.
© Copyright Pearson Education. All rights reserved.
During my 15 years at Microsoft, I have spent 10 years working in vari¬ous product groups shipping 11 products, including Windows NT, Visual Studio, BackOffice, Small Business Server, and the Microsoft Mouse
During my 15 years at Microsoft, I have spent 10 years working in various product groups shipping 11 products, including Windows NT, Visual Studio, BackOffice, Small Business Server, and the Microsoft Mouse. I have also been on a couple of canceled projects that never made it out the door. For the past 5 years, I have been consulting on Microsoft's best source code control (SCC), build, test, and deployment processes, with an emphasis on the build process. It seems that for all the years that I have been working at Microsoft, I have always been in some kind of Software Configuration Management (SCM) role working in the build lab, writing and running tests, creating setup programs, or coordinating project meetings.
This book contains the knowledge I have gained while working on these various projects. Furthermore, I have built on the experiences of the people who were there before me and the lessons they taught me. I also gathered a lot of tips from people who are currently in the product team.
Many things can and have been said about Microsoft, but there is one thing most people will agree on: Microsoft has been one of the more successful companies when it comes to shipping software. Sure, we might be notorious for missing our ship date, but despite this fact, Microsoft cranks out hundreds of released software products per year—thousands if you include hotfixes via Windows Update. That is why we have all the processes mentioned in this book: to minimize the slippage and optimize the development process.
I tried to capture the best new and classic processes that we have developed throughout the years so that I could pass them on to you in The Build Master: Microsoft's Software Configuration Management Best Practices.
What This Book Is About
As I search Microsoft's job database, looking through 397 job titles, none of them contains the words Software Configuration Management. When I look at our acronym or glossary lookup tool and search for SCM, the results come back with Source Code Manager or Supply Chain Management, pronounced SCuM. It is no wonder that the SCM term is used infrequently at Microsoft. I know that I would not like to be referred to as a SCuM manager or champion.
Of course, I am being facetious and picky about the semantics here because SCM is a widely used industry term. It just isn't used a lot at Microsoft. The only explanation I can think of is that the processes of SCM at Microsoft are broken down to specific tasks, and SCM is too broad a term to be used to describe these processes on a daily basis. So, despite the lack of the use of the term SCM at Microsoft, that is what this book is focused on since that is what we live and breathe every day.
Defining Software Configuration Management
Let's define SCM as it is used in this book. I like this definition of configuration management that Steve McConnell gives in his 1993 book, Code Complete, from Microsoft Press:
Configuration management is the practice of handling changes systematically so that a system can maintain its integrity over time. Another name for it is change control. It includes techniques for evaluating proposed changes, tracking changes, and keeping copies of the system as it existed at various points in time.
A more detailed description might be from Stephen A. MacKay. He quotes several sources, but they all seem to be saying the same thing:
The most widely used definition of software configuration management (SCM) comes from the standards community IEEE87, IEEE90a, IEEE90b, Buck93. Configuration management (CM) is a discipline that oversees the entire life cycle of a software product or family of related products. Specifically, CM requires identification of the components to be controlled (configuration items) and the structure of the product, control over changes to the items (including documentation), accurate and complete record keeping, and a mechanism to audit or verify any actions. This definition is not complete. Dart Dart92 suggests that the definition should be broadened to include manufacturing issues (optimally managing the construction of the product), process management (ensuring adherence to the defined processes), and team work (supporting and controlling the efforts of multiple developers). Tichy Tich88 provides a definition that is popular in the academic and research communities: Software configuration management is a discipline whose goal is to control changes to large software system families, through the functions of component identification, change tracking, version selection and baselining, software manufacture, and managing simultaneous updates (teamwork).
In short, at Microsoft, SCM is broken into three groups: source control, build, and deployment or release. There could arguably be a fourth group, sustained engineering—hotfixes and service packs—but this separate distinction seems to show up only on the big teams such as Windows. The jobs at Microsoft that have the responsibilities described previously are builder, build management, or release program manager.
The really abbreviated term for SCM at Microsoft is builds. This is probably because when code is taken from developers and turned into a product that you can deliver to a customer, it is usually the build team that owns all the steps involved or helps manage the process.
Having a good build process seems to be a lost art even in some groups at Microsoft. For example, when I recently spoke with one development team, I heard them talk about trying a distributed build system over a group of build machines (also known as build farms). This idea was tried several years ago—and tried a few times since the original—but has proven to be unsuccessful for various reasons that are covered in Chapter 5, "Build Tools and Technologies." Maybe there have been recent improvements in tools, or the product has been broken into smaller packages of code (componentized) that will make this distributed build process more likely to succeed today than it did years ago. If so, this might justify revisiting the idea even though it was abandoned the last time someone looked at it. But if no changes have been made that would support moving to a distributed build process, trying to pursue this Holy Grail would be a waste of everyone's clock cycles.
It is impossible to talk about software builds without also addressing some of the surrounding software development areas around this process, such as source tree configuration and the deployment of a product. Therefore, I want to give the full story of setting up your development source trees, building your code, deploying your product, and supporting your customers with fixes by using examples of how we do it at Microsoft.
Who Should Read This Book
The target audience for this book is SCM teams at any company that ships software internally or externally. This includes the people outlined in the next sections.
Information Technology (IT) Managers
If you develop or deploy software to departments within your company or manage the servers that host your developer's source code trees, this book will help you succeed in being more efficient and robust.
Software Development and Testing Managers
Because you are the one who implements and uses these processes, it would be best to read the explanations behind the processes firsthand. This will help you drive the adoption of these processes within your group or company.
Build Teams and Build Managers
Being a builder at heart and spending many years in build labs, I wrote this book as a collection of what I have learned. When software is shipped, everyone seems to have specific tasks or jobs: Developers write the code, testers test the code, program or product managers try to figure out what goes into the product, and executives sell it. So who makes sure that the flow of the product does not get interrupted? When there is a block or showstopper, who is the person who will jump through fire hoops to get things started again? It is the build or integration team, which I see as the "heart" of the product and everything else is the "soul." Because this large responsibility falls under the build team, and the most successful groups have a very solid build team, the topics in this book will help you keep the "flow" going.
Technical Project and Product Managers
If you want to be able to accurately predict when your product will be ready for release and learn the details of how a requested application feature goes from cradle to grave, this book will provide an overview of the whole process. You can work with the developers and testers on how to merge these recommendations into your current process and understand the language or lingo.
Anyone Interested in a Microsoft Case Study
Although this book is not intended to be a case study in the traditional sense, such as presenting the steps that Microsoft uses to build software and then analyze them to death, you can view this book as an example of a successful software company and the lessons it has learned over the years, with a lot of insight into why Microsoft chose a particular path.
Assumptions Made on the Background of People Reading This Book
This book assumes that the reader has some experience working on or with a software development team either at a company or in an academic institution. This is not a high-level 35,000-foot view of SCM. Plenty of books out there already take that approach. I am taking a more granular approach as to how to do it rather than just telling you what you need to do.
Although some examples in this book concern Microsoft tools and technologies, I have tried to write this book in a tool-agnostic way. In other words, regardless of the tools or platforms that you develop on, you will still be able to use these processes to ship your software effectively. By "ship your software," I mean any way that software can be delivered to your customers, whether via the Internet, disc media, internal server releases, Web services and applications, or out of the box.
How This Book Is Organized
Each chapter can stand alone, but the book flows from software development processes to product support (sustained engineering). This is my idea of componentizing the build process and this book. You will get a better understanding of how all these topics are linked if you read this book from cover to cover, but I realize that some groups or companies will not need to spend a lot of time on a certain subject that they feel they have already mastered or are not interested in. If someone just wants help on setting up a build lab, he can turn to Chapter 4, "The Build Lab and Personnel," and get the information he needs without having to read the previous chapters.
Contents at a Glance
Because it seems that the build team members tend to live in the source code trees and are usually the administrators of the trees, I spend a chapter talking about the best way to configure your sources.
This is the cornerstone of this book. Nine chapters cover, in detail, how to build your product. For a more in-depth overview, please read the book's Introduction.
This is another area that tends to spill over to the build team's responsibilities. This topic is covered in three chapters.
This tends to be the first area where symptoms of a failing project start to show up. Most notably, everyone on the project team is in reactive mode instead of working on new features.
If you are interested in the new tools that Microsoft will be releasing with the future release of Visual Studio, I touch on how to utilize those tools using the processes described in this book.
As I write this, Microsoft is productizing some of its internal development-cycle tools to make them available to all developers via its Visual Studio Team System product. The production of this book could not have come at a better time because I can now explain how these tools and processes have evolved in addition to the best practices of product teams that drive the functions of these new tools. This is another objective of this book.
I recently completed a build architecture review for a large Microsoft customer. This customer already had a good build process and didn't think it needed much improvement. At the end of my onsite, week-long engagement at the customer's development headquarters, I suggested that this customer adopt the principles that I explain in more detail in this book. He agreed with me on most points but surprised me when he said, "I really appreciate all the information and suggestions that you provided. In order for you to have come up with all of these recommendations, you must have suffered through a lot of pain in the past." This statement blew me away. I never really viewed all of this experience working on builds at Microsoft for the past 15 years as painful, but just lessons we learned by "try and try again until we get it right."
Although some initial investment in resources will be required to reboot your processes if you decide to implement all the processes and suggestions in this book, you will save 3 to 5 years of the "pain" of learning all of this from the school of hard knocks. At the very least, you will be enlightened on how software is shipped at Microsoft. And as I always ask my customers, if you know of any other better processes than what I prescribe, please let me know. I am always open to improvement and would love to hear your suggestions.
Get Stuck or Get Results. Period.
The goal of this book is to get you unstuck from spinning your development cycles or to help you avoid getting stuck in the first place by providing processes and tips to help you become more productive.
What do I mean by "getting stuck"?
At the end of the day, all these issues, which you could avoid, will end up costing your company lots of money because you will be patching or hacking whatever process you currently have that does not seem to be getting the job done.
Nowadays, it is unlikely to have all of an application's developers physically situated at one location. If you plan to have developers work remotely either offsite or off-shore, it is mandatory that you integrate the processes explained in this book, especially the concept of the Virtual Build Labs (VBLs) explained in Chapter 2, "Source Tree Configuration for Multiple Sites and Parallel (Multi-Version) Development Work." Experience shows that if your software configuration management is good, outsourcing will be easy or easier to integrate. This book covers all the necessary steps toward making sure the intellectual property of your company is not compromised. This is done through securing your overall build process, not through fingerprinting every piece of code that is in your project.
What This Book Is Not About: Software Factories
Well, maybe this book has something to do with software factories because you can package everything I talk about in this book, put it in one application, add a few enterprise e-commerce development tools, and crank out your software. Then I think you have a software factory. Or at least that is how I understand the concept of software factories. Everything I read on this topic keeps pointing me to Visual Studio Team System (VSTS). I give an overview of the VSTS tools in Chapter 18, "Future Build Tools from Microsoft," but nothing more. Maybe in another edition of this book, I will talk about how you can use the processes in this book in conjunction with VSTS.
Updates and Contact Information
For updates, visit my blog at http://blogs.msdn.com/vincem/. That's also the best way to contact me. Or you can contact me at email@example.com or http://www.thebuildmaster.com.
For more information on how Microsoft can help provide custom solutions to any software issue, please look at the Microsoft Partner Advantage site at http://www.microsoft.com/services/microsoftservices/default.mspx.
For other books from Addison-Wesley, go to http://www.awprofessional.com.
© Copyright Pearson Education. All rights reserved.
|Ch. 1||Defining a build||1|
|Ch. 2||Source tree configuration for multiple sites and parallel (multi-version) development work||17|
|Ch. 3||Daily, not nightly, builds||35|
|Ch. 4||The build lab and personnel||43|
|Ch. 5||Build tools and technologies||55|
|Ch. 6||SNAP builds - aka integration builds||65|
|Ch. 7||The build environment||75|
|Ch. 9||Build security||101|
|Ch. 10||Building managed code||111|
|Ch. 11||International builds||123|
|Ch. 12||Build verification tests and smoke tests||133|
|Ch. 13||Building setup||145|
|Ch. 14||Ship it!||155|
|Ch. 15||Customer service and support||163|
|Ch. 16||Managing hotfixes and service packs||171|
|Ch. 17||7 suggestions to change your corporate or group culture||183|
|Ch. 18||Future build tools from Microsoft||203|
|App. A||Embedded builds||215|
|App. B||Extreme programming||219|
|App. C||Testing guide||229|
|App. D||Debug symbols||237|
Posted February 1, 2006
The author of this book, Vincent Maria, appears to have extensive knowledge of and experience with the build process at Microsoft. His knowledge if presented properly would be a very interesting and valuable book. Unfortunately, this book fails to deliver. I was looking forward to reading this book, so maybe my expectations were high. I can't recommend this book - it lacks content. The book is a little over 200 hundred pages and has 18 chapters. If you factor out the introductions and graphics, you get about 8 or 9 pages of content per chapter. It would be very difficult to cover any of the chapter topics in detail in 9 pages. What you get is a very high level introduction to a topic with very little usable information. Given the short length of the book, it would be more acceptable if the author were very concise. Unfortunately, I found his writing style to be redundant. Also, the book seems to be stretching for content. For example, there are actually 2 pages of email rules like 'never open attachments from strangers', 1 page on why you should learn XML and of course, there is almost a whole chapter dedicated to how great the new Microsoft Team Foundation product is. I think about a quarter of this book could have been removed without losing anything. Some of the recommendations in this book are childish and unprofessional. For example, one side note included tips for test managers to 'Say 'no' to development at least once a day.' and 'If people really want you to do something, they'll ask at least twice.' and 'On a regular basis, complain that the project is off track...' The book is not completely bad. It is just not detailed enough to be useful. If you are implementing a build process from scratch, you might get a good overview from this book, but I would argue you could get better information from the Internet. One good source would be white papers from the patterns and practices group at Microsoft. There are also some good sources on build automation in the extreme and agile programming texts. If you are looking for a good resource on branching, check out Software Configuration Management Practices by Berczuk.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.
Posted November 5, 2005
If you have a team of 30 or more programmers, then Maraia offers good suggestions on how to design your build processes so that these can both handle your current team, and scale up to hundreds or even thousands of programmers. The book uses Microsoft's own development effort as the central case study. Given that Microsoft has massive software development efforts, you may want to pay attention. The book can be read at two levels. One is if you want to use the development tools from Microsoft, that the book talks about. If your team works under a Microsoft operating system, and uses Visual Studio, then indeed, this can be germane. But you don't have to be using any Microsoft product at all, to reap some gain from the text. The key idea is to have a group of developers who maintain a centralised build process. (They can certainly have other duties.) Here, the book argues about having a metalevel, if you will. Where this build process can and will change over the project's lifetime. If the project has several subgroups, as it will if it is large enough, then each subgroup uses this same central build to make its own binaries. The centralising fights a natural tendency for a large project to have subgroups that drift apart. In part by imposing a top-down discipline on the subgroups to have their developments conform to this build. The book also goes into various good practices that your group should use. These have been covered in other books on software projects. The distinctive part of the text is the above discussion on the centralised build.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.