Feature Reuse Across Software Releases During Software Evolution1

2021 ◽  
Author(s):  
Cezary Boldak ◽  
Stanislaw Jarzabek ◽  
Junling Seow
Keyword(s):  
Software Reuse ◽  
Software Evolution ◽  
Version Control ◽  
Software Components ◽  
Post Mortem ◽  
Feature Location ◽  
Control Approach ◽  
Generative Mechanisms ◽  
Program Components ◽  
Control Tool

Software evolution relies on storing component versions along with delta-changes in a repository of a version control tool such a centralized CVS in old days, or decentralized Git today. Code implementing various software features (e.g., requirements) often spreads over multiple software components, and across multiple versions of those components. Not having a clear picture of feature implementation and evolution may hinder software reuse which most often is concerned with feature reuse across system releases, and components are just means to that end. Much research on feature location shows how important and difficult is to find feature-related code buried in program components post mortem. We propose to avoid creating the problem in the first place, by explicating feature-related code in component versions at the time of their implementation. To do that, we complement traditional version control approach with generative mechanisms. We describe salient features of such an approach realized in ART (Adaptive Reuse Technology, http://art-processor.org), and explain its role in easing comprehending software evolution and feature reuse. Advanced commercial version control tools make a step towards easing the evolution problems addressed in this paper. Our approach is an alternative way of addressing the same problem on quite a different ground.

Framework for Semantic Search Enabled Software Component Repository (SSESCR)

2018 ◽  
Author(s):  
Vishnu Sharma ◽  
Vijay Singh Rathore ◽  
Chandikaditya Kumawat
Keyword(s):  
Software Quality ◽  
Software Reuse ◽  
Development Time ◽  
Software Component ◽  
Semantic Search ◽  
Easy Access ◽  
Software Components ◽  
Efficient Search ◽  
Systematic Reuse ◽  
New System

Software reuse can improve software quality with the reducing cost and development time. Systematic reuse plan enhances cohesion and reduces coupling for better testability and maintainability. Software reuse approach can be adopted at the highest extent if relevant software components can be easily searched, adapted and integrated into new system. Large software industries hold their own well managed component libraries containing well tested software component with the project category based classification .Access to these repositories are very limited. Software reuse is facing so many problems and still not so popular. This is due to issues of general access, efficient search and adoption of software component. This paper propose a framework which resolves all of the above issues with providing easy access to components, efficient incremental semantics based search, repository management, versioning of components.

Analyzing Growth Trends of Reusable Software Components

2013 ◽  
pp. 40-54 ◽  
Author(s):  
Kuljit Kaur
Keyword(s):  
Software Evolution ◽  
Point Of View ◽  
Software Components ◽  
Data Set ◽  
Reusable Components ◽  
Reusable Software ◽  
Evolution Analysis ◽  
Software Modules ◽  
Almost All ◽  
Monitoring Software

Reusable software components are the software modules that can be (re)used across a number of applications in a particular domain. Component users prefer to use those components which can be adapted easily for their changing requirements. So components have to evolve continuously in order to attract users. This chapter focuses on the evolutionary aspects of software components. It mentions various techniques for monitoring software evolution. It uses metrics based analysis as the technique to show software evolution of 15 reusable components from the point of view of their size, complexity, and functionality. The evolution analysis is motivated by laws of software evolution which suggest that as software ages, it increases in size and complexity (unless it is managed) and it has to offer increased functionality to please its users. The findings of the study indicate that the size of the software components (in this data set) grows at a linear rate, and complexity is well managed. However, increase in functionality is sub linear for almost all the components. It remains almost constant for some of them.

An Approach to Formal Specification of Component-Based Software

2011 ◽  
pp. 34-42
Author(s):  
Tarek Zernadji ◽  
Raida Elmansouri ◽  
Allaoua Chaoui
Keyword(s):  
Software Engineering ◽  
Software Reuse ◽  
Formal Specification ◽  
Component Composition ◽  
Software Systems ◽  
Software Components ◽  
Design Component ◽  
Component Design ◽  
Component Based Software Engineering ◽  
Expected Benefits

Current research on software reuse in Component Based Software Engineering (CBSE) covers a variety of fields, including component design, component specification, component composition, component-based framework. CBSE is quickly becoming a mainstream approach to software development and most researchers are hoping that it will be solutions to all the problems that led to software crisis. The software engineering techniques specific to this discipline, in phases such as modeling, verification or validation of component based software systems still insufficient and need more research efforts. ECATNets (Extended Concurrent Algebraic Term Nets) are frameworks for specification, modeling and validation of concurrent and distributed systems. They are characterized by their semantics defined in terms of rewriting logic. The objective of this article is to propose a formal specification of software components by using ECATNets formalism. The expected benefits of this work are: Offer a formal notation for describing the different features of concurrent and distributed software components; Defining a formal unambiguous semantic to describe behavior of the composed system.

scholarly journals Encouraging Software Reuse

2016 ◽  
Author(s):  
Mark Lemley
Keyword(s):  
Software Reuse ◽  
Legal Protection ◽  
Computer Code ◽  
Copyright Law ◽  
Patent Law ◽  
Software Components ◽  
Primary Means ◽  
Stark Contrast ◽  
The Way

In the last fifteen years, the primary means of legal protection forcomputer software has shifted from copyright to patent. We argue that oneunanticipated effect of this trend may be to encourage software reuse.Traditionally, computer programmers have reinvented software components,coding programs from scratch each time a new one is desired rather thanbuying and reusing existing components. This process is inefficient, and isin stark contrast to the normal practice in other engineering disciplines.We argue that copyright law encourages reinvention and discourages thedevelopment of a market for tradeable software components because it allowscompetitors to appropriate the value of a new software invention withoutpayment to the original developer of that invention, but forbidscompetitors from copying the computer code implementing that invention. Theresult is that competitors take inventions from others, but write their owncode to implement those inventions. By contrast, patent law gives strongprotection to inventions, forcing competitors to license the patent inorder to make any product incorporating the idea. It is reasonable toexpect that one effect of increasing reliance on patent law will be anincrease in licenses of both the patented idea and the implementing code.This licensing should in turn pave the way for the trading and reuse ofsoftware components.Note: This paper was published in its final form at 49 Stan. L. Rev. 255(1997).

scholarly journals Implementing Clustering Based Approach for Evaluation of Success of Software Reuse using K-means algorithm

2013 ◽  
Vol 4 (3) ◽  
pp. 807-812
Author(s):  
Jagmeet Kaur ◽  
Dr. Dheerendra Singh
Keyword(s):  
High Precision ◽  
Software Reuse ◽  
Software Components ◽  
Key Factors ◽  
Reusable Software ◽  
The Past ◽  
Failure Factors

A great deal of research over the past several years has been devoted to the development of methodologies to create reusable software components and component libraries. But the issue of how to find the contribution of the factor towards the successfulness of the reuse program is still in the naïve stage and very less work is done on the modeling of the success of the reuse. The success and failure factors are the key factors that predict the successful reuse of software. An algorithm has been proposed in which the inputs can be given to K-Means Clustering system in form of tuned values of the Data Factors and the developed model shows the high precision results , which describe the success of software reuse.

scholarly journals A Method Based on Naming Similarity to Identify Reuse Opportunities

2017 ◽  
Vol 10 (1) ◽  
pp. 99-121 ◽  
Author(s):  
Johnatan Oliveira ◽  
Eduardo Fernandes ◽  
Maurício Souza ◽  
Eduardo Figueiredo
Keyword(s):  
Development Strategy ◽  
Software Quality ◽  
Software Reuse ◽  
Software Systems ◽  
Similarity Function ◽  
Software Components ◽  
Specific Domain ◽  
Prototype Tool

Software reuse is a development strategy in which existing software components are used to implement new software systems. There are many advantages of applying software reuse, such as minimization of development efforts and improvement of software quality. Few methods have been proposed in the literature for recommendation of reuse opportunities. In this paper, we propose a method for identification and recommendation of reuse opportunities based on the similarity of the names of classes. Our method, called JReuse, computes a similarity function to identify similarly named classes from a set of software systems from a specific domain. The identified classes compose a repository with reuse opportunities. We also present a prototype tool to support the proposed method. We applied our method, through the tool, to 72 software systems mined from GitHub, in 4 different domains: accounting, restaurant, hospital, and e-commerce. In total, these systems have 1,567,337 lines of code, 57,017 methods, and 12,598 classes. As a result, we observe that JReuse is able to identify the main classes that are frequent in each selected domain.

scholarly journals A Method Based on Naming Similarity to Identify Reuse Opportunities

2016 ◽  
Author(s):  
Johnatan Oliveira ◽  
Eduardo Fernandes ◽  
Maurício Souza ◽  
Eduardo Figueiredo
Keyword(s):  
Development Strategy ◽  
Software Reuse ◽  
Extraction Methods ◽  
Software Systems ◽  
Similarity Function ◽  
Software Components ◽  
Product Lines ◽  
New Methods ◽  
Prototype Tool ◽  
Software Product

Software reuse is a development strategy in which existing software components, called reusable assets, are used in the development of new software systems. There are many advantages of reuse in software development, such as minimization of development efforts and improvement of software quality. New methods for reusable asset extraction are essential to achieve these advantages. Extraction methods may be used in different contexts including software product lines derivation. However, few methods have been proposed in literature for reusable asset extraction and recommendation of these reuse opportunities. In this paper, we propose a method for extraction of reuse opportunities based on naming similarity of two types of object-oriented entities: classes and methods. Our method, called JReuse, computes a similarity function to identify similarly named classes and methods from a set of software systems from a domain. These classes and methods compose a repository with reuse opportunities. We also present a prototype tool to support the extraction by applying our method. We evaluate the method with 38 e-commerce information systems mined from GitHub. As a result, we observe that our method is able to identify classes and methods that are relevant in the e-commerce domain.

Sign in / Sign up

Export Citation Format

Share Document