Reuse in Agile Development Process

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

Pout2Prot: an efficient tool to create protein (sub)groups from Percolator output files

The protein inference problem is complicated in metaproteomics due to the presence of homologous proteins from closely related species. Nevertheless, this process is vital to assign taxonomy and functions to identified proteins of microbial species, a task for which specialized tools such as Prophane have been developed. We here present Pout2Prot, which takes Percolator Output (.pout) files from multiple experiments and creates protein (sub)group output files (.tsv) that can be used directly with Prophane. Pout2Prot offers different grouping strategies, allows distinction between sample categories and replicates for multiple files, and uses a weighted spectral count for protein (sub)groups to reflect (sub)group abundance. Pout2Prot is available as a web application at https://pout2prot.ugent.be and is installable via pip as a standalone command line tool and reusable software library. All code is open source under the Apache License 2.0 and is available at https://github.com/compomics/pout2prot.

Software Metrics for Reusability of Component Based Software System: A Review

Component Based Software System (CBSS) have become most generalized and popular approach for developing reusable software applications. A software component has different important factors, but reusability is the most citing factor of any software component. Software components can be reused for the development of another software application, which further reduces the amount of time and effort of software development process. With the increase in the number of software components, requirement for identification of software metrics also increased for quantitative analysis of different aspects of components. Reusability depends on different factors and these factors have different impact on the reusability of software components. In this paper, study has been performed to identify the major reusability factors and software metrics for measuring those factors. From this research work, it will become easier to measure the reusability of software components, and software developers would be able to measure the degree of various features of any application which can be reused for developing other software applications. In this way, it would be easy and convenient to identify and compare the reusable software components and they could be reused in effective and efficient manner.

The long and winding road: Accidents and tinkering in software standardization

Software is based on universal principles but not its development. Relating software to hardware is never automatic or easy. Attempts to optimize software production and drastically reduce their costs (like in hardware) have been very restricted. Instead, highly-skilled and experienced individuals are ultimately responsible for project success. The long and convoluted path towards useful and reliable software is often plagued by idiosyncratic accidents and emergent complexity. It was expected that software standardisation would remove these sources of unwanted diversity by aiming to controllable development processes, universal programming languages, and toolkits of reusable software components. However, limited adoption of development standards suggests that we still do not understand why software is so difficult to produce. Software standardisation has been limited by our poor understanding of humans’ role at the origin of technological diversity.

Reuse in Agile Development Process

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

A Novel Clone-Based Reuse Method to Maintain Proficiency in Software Engineering Practice

The source code of an application paves way for a quality software product. Quality software in-turn helps in imposing software reuse. In this paper, pieces of similar codes also known as code clones or code duplications are considered as reusable software components. In general code clones are considered harmful in software engineering practice. They are considered to degrade the quality of software. Code clones are detected and removed without further processing. In this paper, a token- based CodeClone reuse method is proposed to detect type1 and type-4 clones. Positive effects of clones are analyzed and beneficial clones are extracted from the cluster of clones detected. The proposed method aids in the art of developing software thereby enforcing the concept of software reuse. The working principle of the proposed method is implemented using open source software as inputs. Beneficial clones are further stored in a database for future use. Clone report is generated as it assists in knowing about the clone details within a software system.

Sensitivity Analysis of Evolutionary Algorithm for Software Reusability

Fast and competitive software industry demands rapid development using Component Based Software Development (CBSD). CBSD is dependent on the availability of the high-quality reusable component libraries. Recently, evolutionary multi-objective optimization algorithms have been used to identify sets of reusable software components from the source-code of Object Oriented (OO) software, using different quality indicators (e.g. cohesion, coupling, etc.). Sometimes, these used quality indicators are quite sensitive towards the small variations in their values, although they should not be. Therefore, this paper analyzes the sensitivity of the evolutionary technique for three quality indicators used during the identification: Frequent Usage Pattern (FUP), Semantic and evolutionary coupling. The sensitivity analysis is performed on three widely used open-source OO software. The experimentation is performed by mutating the system to different degrees. Results of the empirical analysis indicate that the semantic parameter is most sensitive and important. Ignoring this feature highly degrades the quality; FUP relation is uniformly sensitive and evolutionary relations's sensitivity is non-uniform.