{"id":103,"date":"2009-01-13T12:21:20","date_gmt":"2009-01-13T12:21:20","guid":{"rendered":"http:\/\/www.scmgalaxy.com\/tutorials\/2009\/01\/13\/potential-scm-problem-classes-2\/"},"modified":"2017-12-25T16:31:43","modified_gmt":"2017-12-25T16:31:43","slug":"potential-scm-problem-classes-2","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/potential-scm-problem-classes-2\/","title":{"rendered":"Potential SCM Problem Classes | SCM Potential considerations in an organization"},"content":{"rendered":"

\"potential-scm-problem-classes\"<\/p>\n

When planning for SCM in your product development organization, you must first understand the classes of potential problems that can exist. Once the classes are understood, the inherent problems that are causing configuration management issues may be easily identified.
\nPotential SCM Problem Classes <\/b><\/span><\/span><\/p>\n

    \n
  1. Multiple developer syndrome<\/b>\u2014When you have a project that requires more than one developer, there is the problem with multiple people working on one product base. This could be a test plan, requirements specification, or code. Effort is wasted when two or more people work on the same file and then save it. Without SCM control, the last person to save the file has those changes saved. All the other changes are lost. The simplistic method of locking a file while one person reads it prevents others from simultaneously working on the file.<\/span><\/span><\/li>\n
  2. Multiple releases<\/b>\u2014Enhancements to the base product should result in additional releases of the product containing the latest changes. Once the second release is available, some users are on an earlier release. Having an SCM makes managing those releases possible. When bugs are reported, changes must be made across all impacted releases. As new features become available in the product, they must be made available to all current users, no matter what the release date. <\/span><\/span><\/li>\n
  3. Product family<\/b>\u2014As products are built that offer the same capabilities across a heterogeneous set of hardware platforms, both the common and the platform-specific software bases must be managed. If a product operates on four versions of Windows, three versions of Unix, Red Hat Linux, and FreeBSD the user manual may be significantly the same. But there is a different installation process for all nine platforms. Without SCM, nine individual manuals must be written and maintained. With SCM, one documentation configuration item with nine versions will suffice, with the differences being only the installation procedure.<\/span><\/span><\/li>\n
  4. Requirements change<\/b>\u2014The first law of systems engineering is that no matter where we are in the system life cycle, the system\/software will change, and the desire to change it will persist throughout the life cycle. Dealing with this change represents a major management challenge. Having an SCM in place will ease the management of these changes to the requirements of the products that will occur. An SCM allows the easy identification of feature sets that group the requirements satisfied by a release or version of the product. These feature sets are tracked through development to delivery.<\/span><\/span><\/li>\n
  5. Schedule change<\/b>\u2014As requirements change, so must the schedule. Mapping the feature sets for release to the schedule allows project managers to more accurately estimate the effort required for generating that next release. Having the SCM in place allows the project manager to look at historic effort levels in getting out releases. This is an enormous aid in estimating the “what if” scenarios that result from taking on new product users or providing customized solutions to other clients.<\/span><\/span><\/li>\n
  6. Software changes<\/b>\u2014No product developer has the luxury to write code once and forget about it. Along with requirements and schedules, the software being developed changes in response to those other changes. Software is not static. That is its inherent power. It can<\/i> be changed, so it will be changed. SCM systems track those changes so that, if the wrong change is made, a previous working version is available. This capability alone has saved enormous amounts of time as developers have tried out specific solutions that did not work in the product environment and were able to rapidly back up to a working version.<\/span><\/span><\/li>\n
  7. Staff changes<\/b>\u2014In the best of organizations, people get promoted, take other jobs, and leave. When that happens in the midst of a development project, not just the technology knowledge goes out the door. The long-learned knowledge of how things are done is also gone. So when a replacement person is brought on board, they may know the technology, but without a documented SCM process, they will have no real idea how to do product development. SCM provides the framework and knowledge base of what has gone on before in the project. A new staff member has one place to go to understand the “how” of the organization’s development process and the “what” of the project to date.<\/span><\/span><\/li>\n
  8. System\/user documentation change<\/b>\u2014No product developer has the luxury to produce in a technology or tool vacuum. All product developers use hardware microcode, operating systems, tools, and documentation that are not under their control. When a major operating system change occurs (e.g., the next “best” release of Windows), an SCM will allow tracing all the CIs, components, and subcomponents that are impacted by that change. The change is isolated, and the amount of effort required to respond to the change can be estimated. This provides a responsible schedule for an upgrade based on situations beyond the organization’s control.<\/span><\/span><\/li>\n<\/ol>\n

    A template that may be used in the creation of a software configuration management plan (SCMP) appears in Appendix F, “Project Artifact Templates.” It includes management issues (organization, responsibility, etc.), SCM activities (configuration item identification, change control, status accounting, audit, and reviews), tools, techniques and methods, supplier control, and standards collection and retention.<\/span><\/span><\/p>\n

    SCM Staffing <\/b>
    \nOn any given project, a few engineers or developers specialize in and become your SCM experts. While they are the gurus, everyone on your project will be a user of the product that they select, develop, and maintain. It is better to have a few highly experienced people than a large number of inexperienced people. These experienced few must be able to see congruence between software products and perceive what is missing from a software product.
    \nWe can group the characteristics and abilities needed by the four SCM functions: identification, control, auditing, and status accounting.<\/span><\/span><\/p>\n

    Identification<\/span><\/span><\/h4>\n
      \n
    1. Ability to see partitions<\/span><\/span><\/li>\n
    2. Ability to see relationships<\/span><\/span><\/li>\n
    3. Some technical ability<\/span><\/span><\/li>\n
    4. System engineering orientation<\/span><\/span><\/li>\n
    5. Programming<\/span><\/span><\/li>\n<\/ol>\n

      Control<\/span><\/span><\/h4>\n
        \n
      1. Ability to evaluate benefits versus cost<\/span><\/span><\/li>\n
      2. System viewpoint (balance of technical\/managerial, user\/buyer\/seller)<\/span><\/span><\/li>\n
      3. An appreciation of what is involved in engineering a software change<\/span><\/span><\/li>\n<\/ol>\n

        Auditing<\/span><\/span><\/h4>\n
          \n
        1. Extreme attention to detail<\/span><\/span><\/li>\n
        2. Ability to see congruence<\/span><\/span><\/li>\n
        3. Ability to perceive what is missing<\/span><\/span><\/li>\n
        4. Extensive experience with technical aspects of system engineering or software engineering<\/span><\/span><\/li>\n<\/ol>\n

          Status Accounting<\/span><\/span><\/h4>\n
            \n
          1. Ability to take notes and record data<\/span><\/span><\/li>\n
          2. Ability to organize data<\/span><\/span><\/li>\n
          3. Some technical familiarity<\/span><\/span><\/li>\n
          4. System engineering orientation<\/span><\/span><\/li>\n
          5. Programming<\/span><\/span><\/li>\n<\/ol>\n

            Once the staffing of the SCM function is complete and the overall organization’s SCM policy is established, the configuration control board (CCB) is identified. The CCB is the heart of the control function. It infuses sustained visibility into the process of change throughout the system life cycle and traceability into the process of change. The membership in the CCB is not limited to the developers or product line management. All stakeholders in the product must be represented. This includes the end-user usually represented by marketing, subcontractors used in the product development, product development funders, and the product developers. The CCB is the final decision maker as to what bug fixes, enhancements, and feature sets get included in the next product release.
            \nThe CCB has periodic meetings, with the results documented. These meetings can be done in a rapid fashion, and doing them online or via email is an adequate way to gain consensus and come to a decision. Important to status accounting is the documentation of CCB meeting minutes. The basic purpose of the minutes is to provide the CCB decision makers with the information needed to make intelligent, informed decisions. The amount of detail varies with the meeting frequency and technical content.<\/span><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

            When planning for SCM in your product development organization, you must first understand the classes of potential problems that can exist. Once the classes are understood, the inherent problems that are causing configuration management issues may be easily identified.
            Potential SCM Problem Classes <\/b><\/span><\/span><\/p>\n

              \n
            1. Multiple developer syndrome<\/b>\u2014When you have a project that requires more than one developer, there is the problem with multiple people working on one product base. This could be a test plan, requirements specification, or code. Effort is wasted when two or more people work on the same file and then save it. Without SCM control, the last person to save the file has those changes saved. All the other changes are lost. The simplistic method of locking a file while one person reads it prevents others from simultaneously working on the file.<\/span><\/span><\/li>\n
            2. Multiple releases<\/b>\u2014Enhancements to the base product should result in additional releases of the product containing the latest changes. Once the second release is available, some users are on an earlier release. Having an SCM makes managing those releases possible. When bugs are reported, changes must be made across all impacted releases. As new features become available in the product, they must be made available to all current users, no matter what the release date.
              \n","protected":false},"author":1,"featured_media":3946,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[2],"tags":[422,2867,255,843,2862,2863,2870,2866,351,2864,397,2871,2873,2872,2865,2874,2869,2868,2435,2875],"class_list":["post-103","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorised","tag-classes","tag-classes-of-potential-problems-in-scm-process","tag-issues","tag-organization","tag-potential","tag-potential-problems","tag-potential-scm-considerations","tag-potential-scm-problem-classes","tag-problem","tag-problem-classes","tag-scm","tag-scm-considerations","tag-scm-issues","tag-scm-potential-considerations","tag-scm-potential-problems","tag-scm-problems","tag-scm-process-potential-issues","tag-scm-process-potential-problems","tag-software-configuration-management","tag-software-configuration-management-potential-problem-classes"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/103","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=103"}],"version-history":[{"count":3,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/103\/revisions"}],"predecessor-version":[{"id":3949,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/103\/revisions\/3949"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media\/3946"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=103"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=103"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=103"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}