Software Change Management Process - Case Study Example

Computing Program Evaluation – why is change inevitable? Program system changes are found to be rather inevitable and ultimately tend to become more complex over time as they are used in practice. It is common knowledge that rarely does anything tend to function according to plan and as such it is found that program projects are no exception to this rule. In essence changes in program systems are evidently bound to happen and the manner in which one deals with them will determine just how successful a given project will become. Some of the more common reasons that necessitate that program changes be implemented include influential customers suddenly requesting for demos or beta/alpha builds of given program. This can at times program developers to have to drop all their currently ongoing projects and focus on changing the program and developing it into a stable build. Program systems that experience many test failures often require that the program systems become changed in an effort to fix these errors (Afshar and Padenga 2010). Another common reason that necessitates that program changes be made include the death, resignation or departure of a key member of the program design team. Unless a program design project team has been careful to review, test and document all the pieces of code that go into the development of a given program system, program programrs taking over from an absent developer will have to spend a rather considerable amount of time attempting to get the entire program system going (Saleh 2009). Another common reason as to why change in program system is considered to be inevitable is as a result of the customers or marketers requesting for additional changes to the program. The changes in program system in this instance are made necessary by the feedback that the developers receive pertaining to the impact and effectiveness of the program. By making modifications to the program based on this feedback, developers are able to ensure that it is able to better satisfy the needs and requirements of its target users. Reducing the effects of change within FASAM Most organizations often tend to have a well defined and formal process that can effectively be utilized in the handling of bug fixes and RFE’s. However, there are still some organizations that tend to have poor structures to guide them in handling any changes, in some of the organizations where such structures are available, these structures can frequently be ignored by both the program developers and the organizational management with the objective of attaining some short term conveniences. Requirements changes in a program like FASAM can cause a massive degree of havoc in its development process in the event that the effects of changes end up rippling through relatively large parts of its system and program design, which may in turn affect other essential parts until FASAM’s conceptual model and overall design becomes so affected that it actually degrades. Hopefully when developers are forced to make changes to the highest-level of the program, most of its abstract requirements will not be affected although they are sometimes affected as system requirements gradually become better understood. To minimize the effects of change within FASAM, it is important for the FASAM engineering team to ensure that even if there are no clear change process guidelines at the organizational level, it effectively develops its own guidelines to help it in implementing changes within FASAM that will have minimal negative effects on the program. The consequences of not having proper program change processes within a program like FASAM can at times be quite disastrous not only for the engineering team, but also for its users as they might face the risk of being stuck with a program having numerous bugs as a result of not enough care and testing having undergone into its change process. Such a program might cause users to loose or corrupt their data. Maintenance change control process Once a program has been developed, it is often found that bugs arise that result in the need for maintenance. it is important to have a maintenance change control process in place that will be of aid in helping define just how items are handled and the path that will be taken to the completion of the tasks at hand. The use of different tools to help in logging these changes, bugs and requests is deemed to be importance in helping keep things relatively organized while allowing for the proper tracking of these items (Jarzabek 2007). Change control is commonly perceived as being a key part of program maintenance. Change control is mainly used in helping the developers to effectively keep track of the different versions of code that emerge, as different code versions for the very same program gradually changes so as to accommodate bugs or new requests. If the maintenance change control process is not handled properly, it can result in causing a lot of confusion which might potentially prevent the right changes from moving on into a production environment (April and Abran 2012; Moreira 2004). The program maintenance change process is considered to be a long-term tier support system that is of crucial importance in all computer-based business systems. In the current information age, most businesses are seen to have grown dependent on error proof and scalable program platforms (Lewis 2012). The provision of support by program manufacturers is as such found to be of critical importance not only for the business owners but also in securing the program’s longevity. Software manufacturers are deemed to be responsible for the fixing of latent errors, making required updates and offering support for the user-related questions. It is because of this that it is deemed to be important for all program firms to ensure that they have in place well-organized and strong program maintenance plans that carefully document any changes that are made to a given program (Reifer 2012). In the software maintenance change process, the request for a software version change is often seen to be requested while the system engineering and user’s maintenance teams are engaged in negotiation the updated version content of the software. After the negotiations, the maintenance control board analyzes the review plans before eventually scheduling a specific time frame within which the new version will be released depending on the project’s budgetary allocations (Donaldson and Siegel 2000). After the release date is announced, the software engineering team goes on to complete work on its design and coding, after this the team then goes on to conduct extensive testing on the newly released software. To ensure that no faults manage to remain undetected during the software’s test processes and final fix, the software goes through regression testing, functional testing, integration testing and performance testing. The final version of the program is eventually attached and then issued (Wang et al. 2007). Software maintenance and change control process are generally very critical elements in the guaranteeing of the continued success of any software package. By following predefined standard operating procedures, adhering to proper escalation protocols and keeping detailed records, a company can be able to efficiently update and maintain its software products. Key aspects of Maintenance Predictions Maintenance predictions are seen to have a number of key aspects, some of these key aspects include: Fan-in and Fan-out Metrics: This metrics is generally used in the prediction of the overall complexity of maintaining the software. Fan-out is seen to indicate the number of functions that a particular function calls. Modifying a function can potentially have the result of affecting the functions that are designed to be called by the modified function (Oram and Wilson 2010). Functions having a large Fan-out are found to generally be more expensive to maintain. Fan-in is a count of the number of functions that call out a given function. Functions having high Fan-in essentially mean that many functions use this particular function. In the event that the specifications of a function having a relatively large Fan-out are changed, it becomes necessary to modify all the other functions that use it (Ghezzi nd McDermid). Complexity Density: Complexity density is found to generally be inversely proportional to the actual maintenance productivity (Laird et al, 2006). Maintenance productivity is essentially defined as the overall sum of the total number of lines divided by the actual time measured in hours that is seen to be spent on testing upgrades to software, as such, the complexity density metric can be used in predicting the difficulty that will be experienced in maintain a given program (Khan 2002; Baker 1999). KLOC and Commentedness: Commentedness is used to indicate the overall readability of a given program. The Program maintenance and development is found to primarily be a function of program size which is measured in kilo lines of code KLOC (Anderson et al, 2003). According to the length hypothesis, the number of bugs is essentially proportional to the total number of statements in the machine language. KLOC can be used in deriving the cost estimation of future projects, determining productivity and comparison of different products. Most of the current estimation models are seen to depend on the program size (Desikan and Ramesh 2006). Software Reverse Engineering Code Software re-engineering can be defined as the process of going back though a code’s developmental cycle so as to critically analyze a given subject subsystem and be able to create representations of the system at what is relatively a higher level of abstraction (Valenti 2002). Developers can opt to undertake a process of reverse engineering on a given code so as to better understand its design and be able to produce similar, but cheaper versions of the software. This is at times found to be necessary as conducting regular maintenance costs on old software systems can at times be found to be quite expensive. Developers can also undertake a software reengineering process to understand and subsequently make changes to the software that will serve to greatly improve the performance of the given software. Reverse software engineering can also be conducted to help in improving the usability if a given software. In this instance, software reengineering is to help in ensuring the robust and easy handling of the given software. The software re-engineering process of a given code is seen to generally involve a number of key stages: Prescreening: During this stage, the reverse engineers are tasked with determining the code that they will reverse engineer. Some of the popular potential candidates for this kind of a project include units, pats, subassemblies and components (Dhillon 1998). Some of these are seen to contain numerous small parts that are generally sold as a single unit (Dhillon 2002). Decompilation/Disassembly: This is found to be the most time consuming state in the entire process. In this stage, the reverse engineers are seen to attempt to create an accurate characterization of the system by trying to accumulate all the instructions and technical data pertaining to how the given product actually works (Eilam 2013; Sabharwal 2008). Implementing the new data in the replica or modified version: This stage involves the verification of the data generated by the decompilation or disassembly process by creating an accurate reconstruction of the original system. The engineers are able to work on this stage by creating prototypes of the code, testing the system as well as experimenting with the given results (Rada 2000). Creation of a new Product (Introduction into the Market place): This is the last stage of the reverse engineering process. By modifying code, the new products are essentially innovations of the original product with the key distinction that they have more competitive designs, capabilities or features (Mishra and Mohanty 2012). Critical Evaluation Software change management process and software reverse engineering are increasingly becoming important in today’s technological world. The constant need for support and better working product has seen developers offer better support for their products and try to outdo competitors who by using reverse engineering are able to offer more innovative products. As multiple industries move towards the use of computing automation for the effective control of all their daily operations, scalable, customized, stable and more effective software packages continue to become a crucial factor in ensuring that these companies are able to generate high profits (Wang 2006). Bibliography Afshar, M and Padenga. 2010. Application Software Reengineering. [S.l.] : Pearson Education India. Anderson, S. 2003. Computer safety, reliability, and security : 22nd International Conference, SAFECOMP 2003, Edinburgh, UK, September 23-26, 2003 : proceedings. Berlin ; New York : Springer. April, A. and Abran, A. 2012. Software Maintenance Management: Evaluation and Continuous Improvement. John Wiley & Sons. Desikan, S. and Ramesh, G. 2006. Software testing : principles and practice. Bangalore, India Dorling Kindersley (India). Dhillon, S. B. 1998. Advanced Design Concepts for Engineers. CRC Press. Dhillon, S. B. 2002. Engineering and Technology Management Tools and Applications. Norwood : Artech House. Donaldson, S. and Siegel, S. 2000. Successful software development. Upper Saddle River, NJ : Prentice Hall PTR. Eilam, E. 2013. Reversing : secrets of reverse engineering. Hoboken, N.J. : Wiley. Ghezzi, C. and McDermid, J. 1989. ESEC 89 : 2nd European Software Engineering Conference, University of Warwick, Coventry, UK, September, 11-15, 1989 : proceedings. Berlin ; New York : Springer-Verlag. Jarzabek, S. 2007. Effective Software Maintenance and Evolution: A Reuse-Based Approach. CRC Press. Jarzabek, S. 2007. Effective Software Maintenance and Evolution: A Reuse-Based Approach. CRC Press. Kan, S. 2002. Metrics and models in software quality engineering. Boston, [Mass.] ;London : Addison-Wesley. Kenett, R. and Baker, E. 1999. Software Process Quality: Management and Control. Publisher CRC Press, 1999 Laird, L. et al. 2006. Software measurement and estimation : a practical approach. Hoboken, N.J. : Wiley-Interscience. Lewis, E. W. 2012. Software Testing and Continuous Quality Improvement. CRC Press. Mishra, J. and Mohanty, A. 2012. Software engineering. New Delhi, India : Dorling Kindersley. Moreira, E. M. 2004. Software configuration management implementation roadmap : [provides guidance for establishing a global SCM infrastructure]. Chichester [u.a] : Wiley. Oram, A. and Wilson, G. 2010. Making Software : What Really Works, and Why We Believe It. Sebastopol : OReilly Media, Inc. Rada, R. 2000. Reengineering software : how to reuse programming to build new, state-of-the art software. Chicago : Glenlake Publ. Comp. Reifer, J. D. 2012. Software Maintenance Success Recipes. CRC Press. Sabharwal, S. 2008. Software Engineering. New Age International. Saleh, K. A. 2009. Software engineering. Ft. Lauderdale, FL : J. Ross Pub. Valenti, S. 2002. Successful software reengineering. Hershey, PA : IRM Press. Wang, Q. et al,. 2006. Software process change : international software process workshop and international workshop on software process simulation and modeling, SPW/ProSim 2006, Shanghai, China, May 20-21, 2006 : proceedings. Berlin [etc.] : SpringerLink [host]. Wang, Q. et al. 2007. Software process dynamics and agility : International Conference on Software Process, ICSP 2007, Minneapolis, MN, USA, May 19-20, 2007 : proceedings. Berlin; New York : Springer. Read More