Software Reuse Strategies

NB: We do not resell your papers. Upon ordering, we do an original paper exclusively for you.

NB: All your data is kept safe from the public.

Table of Contents

Introduction
Overview of reuse strategies
Application of management methodology to software reuse
Issues around open source and propriety software processes
Conclusion
Works Cited

Introduction

Software reuse is the process by which organizations leverage on knowledge found in code components, test cases and functional designs in order to increase productivity and the quality of their products.

It has become a popular alternative for organizations that want to increase their productivity of their software development efforts. Companies may not always reap the rewards of software reuse at the beginning. As a result, it is essential for them to understand the reuse strategies available to them as well as the effort they must put into those choices.

Overview of reuse strategies

Reuse as part of company work organizations

Reuse may be considered as part of a company’s work organization. In this regard, firms must plan and improve their software development efforts regularly. They need to have a plan in order to determine project requirements ahead of time. Some trade offs will need to occur between cost and time. When companies utilize this reuse strategy, they must incorporate consumer needs within the development process.

Companies ought to have a disciplined path in which they can incorporate software reuse modules and the new products. Continuous improvement should also be a critical aspect of this reuse strategy. Software developers and organizational leaders should get feedback about the outcomes of software reuse so as to improve in the future. All measures should include tasks in software development like component integration, retrieval as well as production (Eduardo et. al. 266).

In this strategy, companies often try process improvements on a small scale then use the knowledge acquired to go full scale. At the small scale level, developers often consider the process as an exploratory one. Any lessons learnt will be documented and applied in future scenarios. Organizations applying this strategy also have a standard process that assists inexperienced developers to succeed in reuse by depending on standardized practices.

Formalization of these processes ensures that participants understand their responsibilities and the relationship between the different aspects of software reuse. In such companies, people are fully aware of the steps between coding and testing so they are able to carry out the process effectively. Structuring ensures that project outcomes have certain standards. Additionally, it helps provide for desirable outcomes (Slinger et. al. 187).

In this strategy, firms need to provide strong management support. They can demonstrate this by allocating sufficient human and financial resources to provide software use. Management support also comes in the form of policies and practices that support reuse. Management needs to ensure that employees have the right training and preparation needed to reuse the software (Eduardo et. al. 264).

Creating libraries of components

In this software reuse strategy, companies will have a software repository from which they build new software and customize code. Since they can easily change existing components to meet new requirements, then high levels of reuse are prevalent using this strategy (Agresti 51).

Flexibility is also gained because developers have the choice of several components. On the flipside, companies cannot share software artifacts or may find it difficult to do so as reuse is mostly restricted to the organization. The repository approach has less risk since companies control the quality of the components in use. Businesses can only recover their investments once they reach a critical mass of components within their libraries (Slinger et. al. 190).

Companies that want to create their own libraries of components must do this in a systematic manner. They often employ parts from real systems to create new ones. These stakeholders make such decisions in order to increase maintainability of the software as well as the time it takes to develop them.

Perhaps most importantly, firms will engage in these endeavors in order to minimize the cost of software development. When a company intends on creating a library of components, then it must exert more effort than if it were writing code for conventional, non reuse purposes (Agresti 55). In this regard, developers ought to create code generically such that users can apply the components in different settings.

Organizations should know that the process of building a software library using reusable components will consume a lot of their resources, and that positive results may only be evident in the future. Additionally, they must be ready to deal with management issues when component libraries start growing exponentially. At that level, duplicated versions of components may arise, so they need to be controlled (Slinger & Finkelstein 189).

Using and reusing externally developed code

Organizations may also utilize externally developed code in their reuse strategies. Here, businesses may take advantage of component markets to develop their software. In such cases, code cannot usually be modified; however, they may configure the code in accordance with certain parameters.

Generally, companies that take such an approach have average reuse rates owing to the limitations of finding codes that fit a company’s requirements (Hill et. al. 241). Even customization processes may be restricted because all the components need to be configured effectively. Organizations buy these components from vendors who sell a variety of them. It can cost the company substantial amounts of financial input to search for externally developed code.

However, when they find them, they may spend a relatively small amount to customize them. When compared to in-house code, component development is more expensive because of parameter configuration. Markets take up the responsibility for managing software artifacts so companies do not have to dedicate a lot of time and money in managing a repository (Hill et. al 239).

Some of the concerns that firms ought to address include the payment of royalties to external code developers, which may exert substantial financial strain upon the company. At first, firms must pay procurement fees; in other circumstances they may have to pay license fees. However, organizations may still use this strategy if the costs involved in licensing, procurement, or royalties are much lower than costs associated with developing the software code from scratch.

The redundancy of software repositories makes upfront investment much lower for reusing externally developed code. This is because one does not have to invest resources in building software libraries; they are sourced from other partners. Such a strategy is also quite risky because companies cannot be certain about the quality of software they are purchasing (Eduardo et. al. 271).

Application of management methodology to software reuse

CMMI and PMBOK

Three themes may be applied in the area of software reuse using CMMI. When reusing software, an organization can borrow the CMMI principle of reusing everything. In this regard, companies must pay attention to architectural issues during software development using preexisting code. In CMMI companies are expected to maximize their processes also; only the effective ones can be applied.

In software reuse, organizations can utilize this philosophy by sticking to those software development processes that have been effective. In CMMI, adherents advocate for the use of effective components. Since software reuse strategies sometimes entail the use of external components, then best practices from CMMI can be applied. The experience they have with component vendors can be applied in software reused (PMI 18).

CMMI also advocates for learning from an organization’s mistakes. Companies must avoid repeating the same mistakes. Therefore, CMMI management philosophies mitigate these problems by first identifying defects, removing them and increasing capability. When taking corrective actions, firms need to consider doing peer review when handling development or building code.

This aspect of learning from one’s past works by doing a root cause analysis. Once the defect is found, then processes for preventing their occurrence should be established. Software reusers can do the same by ensuring that the process of building software repositories, procuring software codes or developing software processes is free of defects (Hill et. al. 236).

Conversely PMBOK can also be applied to the process of software reuse. Software reuse may be necessary when handling a project. PMBOK is applicable to project work, so companies need to merge the basic concepts of the management approach with software reuse. Since PMBOK involves five phases, then companies need to structure software reuse around these processes.

When initiating a project, software processes need to mirror the needs of the project. During the controlling process, software development should also incorporate the needs of the project. Additionally, companies can use aspects such as quality management and scope management to encourage compliance to reuse strategies (PMI 20).

Agile management, lean methodologies

During software reuse, companies can utilize agile management to deliver effective products. The key strategy behind this approach is focusing on the chief priorities. The firm needs to deliver what its stakeholders require while at the same time building on reusable software components for future use.

During software development, users may employ techniques from agile management to improve their effort. Usually, a developer who depends on reuse strategies will need to design, implement and test the iterations. Code reviews may be necessary and so will refactoring; agile methodologies allow the developer to become more flexible (Agresti 50).

In all agile management philosophies, firms must refrain from repeating themselves. Using this principle will allow an organization to keep their code libraries light and of high quality. Additionally, they will not waste time on duplication. One such instance is during the process of refactoring code depending on the level of code that is being handled. Duplication could also be eliminated in the documentation process.

Agile systems are not as centrally planned as traditional approaches. They focus more on particular tools such as customer collaboration or individual needs rather than processes and tools. Therefore, when doing software reuse, agile management philosophies would dictate that users focus on the external environment rather than the internal one. Software reusers can take the same stance and respond to change as it arises.

In agile management processes, software reusers would be people centric rather than process centric. Therefore, code and software developers would focus on the people affected by a project or the clients who commissioned a certain project not the processes needed to complete it. Additionally, knowledge management would be treated as an implicit process than one that is open to numerous possibilities.

Roles in software reuse would be assigned to teams. Companies would depend on groups of software developers to enact reuse. Nonetheless, these team members would be flexible enough to diffuse the roles if the situation necessitates it. Informality increases the speed of reaction to new developments. If software reuse depends on a lot of customer input, then their contribution should take precedence over other factors (Cwalina & Abrams 106).

Other approaches

Traditional approaches, like waterfall, are process-centered ones. Software reusers would depend on existing processes to achieve this. Consequently, waterfall would be more appropriate for company work organizations as a software reuse strategy (refer to part 2.1) rather than use of externally-developed code (refer to part 2.3) as a software reuse strategy. Every project that necessitates the development of new software from existing code would be regarded as an individual assignment.

All participating members would be specialists in their own right. For instance, some of them would be in charge of the code repository while others would be responsible for refactoring. In waterfall, formal processes of communication are paramount in seamless production. The problem with such a management approach is that it hampers reactivity and response to new developments in software reuse (Rosito et. al. 142).

In waterfall, users depend on tasks to determine how long a project would last. This means that stakeholders would be guided by the life cycle model. People who reuse software on the basis of traditional approaches are more likely to exhibit mechanistic systems of governance. Cooperation is not common and projects would take longer than usual. Conversely, the technology to be used during software application would not be as restricted as it is in lean management methods (Agresti 53).

Issues around open source and propriety software processes

As mentioned earlier, organizations may choose software strategies in which they purchase code from external sources or they may develop their own repositories in house. These software reuse strategies can lead to open source or proprietary software.

Open source software refers to readily available software that volunteers make in order to allow software developers to use and customize it as the see fit. On the other hand, proprietary software is software that companies make in house. They have proprietary rights over it and the source code is often kept secret (Cwalina & Abrams 51).

Unlike what one may assume, open source software is not always free even after it is acquired. Firms need to invest substantial financial resources when minor customizations take place. Therefore, they might end up spending more than they expect.

Open source software reusers may need to invest a lot of time in accessing software vendors. Professional services for controlling vendors services are likely to change this problem. Code quality may not be assured in the process as users may access good quality code or not (Slinger & Finkelstein 190).

Security concerns maybe more prevalent in open sources than proprietary software. Individuals belonging to this group may be quite vulnerable to hacking. Companies usually leave a lot of security to chance if they do not develop software in house.

Users also have complained that it is difficult to know about code quality in proprietary software approaches. Sometimes, one may have to weigh the implications of security, pricing, ease of customization as well as code quality in order to determine the most effective solution (Rosito et. al. 144).

Conclusion

Software reuse is an effective way of enhancing company production. However, organizations can reap maximum benefit if they rely on management approaches like agile and CMMI. Tradeoffs between costs and quality have to be made during a software reuse strategy.

Works Cited

Agresti, William. “Software Reuse: Developers’ Experiences and Perception.” Journal of Software Engineering and Applications, 4.1(2011):48-58. Print.

Cwalina, Krzysztof & Brad Abrams. Framework design guidelines: Conventions, idioms and patterns for reusable .NET libraries. NY: Addision Wesley, 2008. Print.

Eduardo Ogasawara,Carlos Paulino, Leonardo Murta, Cláudia Werner & Marta Mattoso. “Experiment Line: Software reuse in scientific workflows. “ Computer Science Journal 5566(2006), 264-272. Print.

Hill, Emily, Lori Pollock & K Vijay-Shanker. “Automatically capturing source code context of NL-queries for software maintenance and reuse.” ICSE Journal 2(2009): 232-242. Print.

PMI. A guide to the project management body of knowledge. NY: Project Management Institute, 2012. Print.

Rosito, Mauricio, Daniel Callegari, Ricardo Bastos. “Project management and software development processes: Integrating PMBOK and OPEN.” International Journal of Computer and Communication Engineering 6(2012): 139-146. Print.

Slinger, Jansen & Anthony Finkelstein. “A sense of community: A research agenda for software ecosystems.” Software engineering 5(2009): 187-190. Print.

Click Here To Order Now!