19,151 research outputs found
Comparative analysis of software reusability attributes in web and mobile applications
Software reuse is an important approach to software engineering, where it aims to use previous software components to create new software systems. Reusability minimizes work repetition, development time, cost, efforts, and increases systems reliability. Reusability measurements help developers to provide the right metrics for measuring the reusability attributes and to identify reusable components among the wealth of existing programs. The main problem encountered in software reuse is the proper selection of the right software component for reuse due to similarity between the desired functionality and the function of the retrieved software component. In addition, it is difficult to define the right metrics that capture important quality attributes of a given class. This research aims to identify and measure the attributes that affect the software components reusability in two open source web and mobile applications. It also aims to compare the usage rate of reusability components in these applications to decide their ability to reuse. Four attributes were selected due to their impacts on reusability namely flexibility, portability, variability and understandability. Five metrics were identified to measure these attributes based on specified formulas. The metrics are Coupling Between Object (CBO), Lack Of Cohesion (LCOM), Depth Of Inheritance (DIT), Number Of Children (NOC) and Line Of Code (LOC). The research results indicate that the same attributes and metrics are suitable for measuring the reusability components in both applications. The comparison between the two applications for reuse indicates that the web application is more difficult for reuse than the mobile application
A Multi-Faceted Software Reusability Model: The Quintet Web.
Over the past decade, problems in software development and maintenance have increased rapidly. The size of software has grown explosively, complexity of software applications has increased, the nature of software applications has become more critical, and large quantities of software to be maintained have accumulated. During the same time, the productivity of individual software engineers has not improved proportionally. Software reusability is widely believed to be a key to help overcome the ongoing software crisis by improving software productivity and quality. However, the promise of software reusability has not yet been fulfilled. We present a multi-faceted software reusability model, a Quintet Web, that enables designers to reuse software artifacts from all phases. The Quintet Web consists of links of five types of reuse support information among existing document blocks: semantic, horizontal, hierarchical, syntactic, and alternative relationships. The five types of reuse support information are named the Semantic Web, the Horizontal Web, the Vertical Web, the Syntactic Web, and the Alternative Web. The Semantic Web defines the operational functionality of each software block. The Horizontal Web links functionally identical blocks of all phases. The Vertical Web identifies hierarchical relationships of software blocks. The Syntactic Web forms a chain from the declaration of each variable to its uses for all variables. The Alternative Web enables software developers to select an alternative algorithm for an identical functionality. The Quintet Web supports both software development and maintenance. When the Quintet Web is applied to development process, it provides software developers a means to check the consistency of the software being developed. The Quintet Web model is independent of a specific software development method
AUTOMATING OUTPUT SIZE AND REUSABILITY METRICS IN AN OBJECT-BASED COMPUTER AIDED SOFTWARE ENGINEERING (CASE) ENVIRONMENT
Measurement of software development productivity is needed in order to control
software costs, but it is discouragingly labor-intensive and expensive. Computer aided
software engineering (CASE) technologies -- especially object-oriented, integrated CASE
-- have the potential to support the automation of this measurement. In this paper, we
discuss the conceptual development of automated analyzers for function point and
software reusability measurement for object-based CASE. Both analyzers take advantage
of the existence of a representation of the application system that is stored within an
object repository, and that contains the necessary information about the application
system. We also propose new metrics for software reusability measurement, including
reuse leverage, reuse value and reuse classification. The functionality and analytic
capabilities of state-of-the-art automated software metrics analyzers are illustrated in the
context of an investment banking industry application.Information Systems Working Papers Serie
Fine Grained Component Engineering of Adaptive Overlays: Experiences and Perspectives
Recent years have seen significant research being carried out into peer-to-peer (P2P) systems. This work has focused on the styles and applications of P2P computing, from grid computation to content distribution; however, little investigation has been performed into how these systems are built. Component based engineering is an approach that has seen successful deployment in the field of middleware development; functionality is encapsulated in âbuilding blocksâ that can be dynamically plugged together to form complete systems. This allows efficient, flexible and adaptable systems to be built with lower overhead and development complexity. This paper presents an investigation into the potential of using component based engineering in the design and construction of peer-to-peer overlays. It is highlighted that the quality of these properties is dictated by the component architecture used to implement the system. Three reusable decomposition architectures are designed and evaluated using Chord and Pastry case studies. These demonstrate that significant improvements can be made over traditional design approaches resulting in much more reusable, (re)configurable and extensible systems
Systematic formulation of non-functional characteristics of software
This paper presents NoFun, a notation aimed at dealing with non-functional aspects of software systems at the product level in the component programming framework. NoFun can be used to define hierarchies of non-functional attributes, which can be bound to individual software components, libraries of components or (sets of) software systems. Non-functional attributes can be defined in several ways, being possible to choose a particular definition in a concrete context. Also, NoFun allows to state the values of the attributes in component implementations, and to formulate non-functional requirements over component implementations. The notation is complemented with an algorithm able to select the best implementation of components (with respect to their non-functional characteristics) in their context of use.Peer ReviewedPostprint (published version
The convenience for a notation to express non-functional characteristics of software components
Software systems are characterised both by their functionality (what the system does) and by their non-functionality (how does the system behave with respect to some observable attributes like performance, reusability, reliability, etc.). Both aspects are relevant to software development. However, non-functional issues have received little attention compared to functional ones. In this position paper we highlight the role of non-functionality, and we claim for a notation to deal with them. We enumerate some design principles for such a notation, and then we make a proposal, which allows to de ne non-functional attributes of software, non-functional behaviour of components with respect to these attributes, and also non-functional requirements over implementations.Peer ReviewedPostprint (author's final draft
Some Initial Guidelines for Building Reusable Quantum Oracles
The evolution of quantum hardware is highlighting the need for advances in
quantum software engineering that help developers create quantum software with
good quality attributes. Specifically, reusability has been traditionally
considered an important quality attribute in terms of efficiency of cost and
effort. Increasing the reusability of quantum software will help developers
create more complex solutions, by reusing simpler components, with better
quality attributes, as long as the reused components have also these
attributes. This work focuses on the reusability of oracles, a well-known
pattern of quantum algorithms that can be used to perform functions used as
input by other algorithms. In particular, in this work, we present several
guidelines for making reusable quantum oracles. These guidelines include three
different levels for oracle reuse: the ideas inspiring the oracle, the function
which creates the oracle, and the oracle itself. To demonstrate these
guidelines, two different implementations of a range of integers oracle have
been built by reusing simpler oracles. The quality of these implementations is
evaluated in terms of functionality and quantum circuit depth. Then, we provide
an example of documentation following the proposed guidelines for both
implementations to foster reuse of the provided oracles. This work aims to be a
first point of discussion towards quantum software reusability. Additional work
is needed to establish more specific criteria for quantum software reusability.Comment: 10 page
Bridging the gap between design and implementation of components libraries
Object-oriented design is usually driven by three main reusability principles:
step-by-step design, design for reuse and design with reuse. However, these
principles are just partially
applied to the subsequent object-oriented implementation, often due to efficienc
y
constraints, yielding to a gap between design and implementation. In this paper
we provide a solution for bridging this gap for a concrete framework, the one of
designing and implementing container-like component libraries, such as STL, Booc
h
Components, etc. Our approach is based on a new design pattern together with its
corresponding implementation. The proposal enhances the same principles that
drive the design process: step-by--step implementation (adding just what is
needed in every step), implementation with reuse (component implementations are
reused while library implementation
progresses and component hierarchies grow) and implementation for reuse
(intermediate component implementations can be reused in many different points o
f
the hierarchy). We use our approach in two different manners: for building a
brand-new container-like
component library, and for reengineering an existing one, Booch Components in
Ada95.Postprint (published version
- âŠ