Increase Software Quality Research Articles

A Comparative Study on State Programming: Hierarchical State Machine (HSM) Pattern and State Pattern

State machines can be implemented by using several methods. Although state pattern (SP) implementation is one of the most popular methods, nowadays usage of hierarchical state machine (HSM) pattern is increasing. In this paper our motivation is making a metric based comparison between HSM and SP pattern. In addition, effect of increase in usage of inheritance in HSM pattern is analyzed. SP and HSM pattern belongs to different software methodologies, thus usage of object-oriented (OO) metrics is not applicable. However, both patterns implement state machines. For this reason, a new metric suit for state machines is proposed. As a result of this study, it is shown that using inheritance effectively in HSM pattern increases software quality. In addition, it is shown that HSM pattern handles enter/exit actions more effectively than SP. event e with the same transition a. Both states go to the same state; S3, with event e. S1 and S2 can be grouped under S12. By doing so, the number of events and transitions is reduced with the help of inheritance.

Marine ecology service reuse through taxonomy-oriented SPL development

Nowadays, reusing software applications encourages researchers and industrials to collaborate in order to increase software quality and to reduce software development costs. However, effective reuse is not easy and only a limited portion of reusable models actually offers effective evidence regarding their appropriateness, usability and/or effectiveness. Focusing reuse on a particular domain, such as marine ecology, allows us to narrow the scope; and along with a systematic approach such as software product line development, helps us to potentially improving reuse. From our experiences developing a subdomain-oriented software product line (SPL for the marine ecology subdomain), in this paper we describe semantic resources created for assisting this development and thus promoting systematic software reuse. The main contributions of our work are focused on the definition of a standard conceptual model for marine ecology applications together with a set of services and guides which assist the process of product derivation. The services are structured in a service taxonomy (as a specialization of the ISO 19119 std) in which we create a new set of categories and services built over a conceptual model for marine ecology applications. We also define and exemplify a set of guides for composing the services of the taxonomy in order to fulfill different functionalities of particular systems in the subdomain.

A Novel Integrated Framework to Increase Software Quality by Mining Source Code

A Novel Integrated Framework to Increase Software Quality by Mining Source Code

Developing tools as plug‐ins: TOPI 2011 special issue editorial

SUMMARYOur knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre‐existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug‐in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug‐ins can be challenging. How do they interact with the core environment? How do they interact with one another ‐ especially since each developer may choose a different set of plug‐ins? How can we share tools across different, and future, core development environments?

An Efficient Automated Tool for Design Time Reusability

development of new applications based on the existing design and code increases software quality. This work shows how design reuse increases software quality. It is important in the development of new software version from the existing applications. It enables the reuse of significant portion of the existing design. Software Reuse is one of the most beneficial aspects of Change Management. This concept provides different kind of modular reusability. The proposed work is about to develop an efficient automated tool for Design Time Reusability to generate different Software Entity Relationship Diagrams (E-R Diagram) and Database creation. Real world situations are captured through Entity Relationship diagrams (E-R Diagram). A key component of the design process in Software development life cycle (SDLC) is the conversion of Entity Relationship Diagrams (E-R Diagram) into Relational model. The mappings are incorporated during the conversion process and a database design is achieved. Here a methodology is described for the design of a Relational database based on the E-R model by performing the reusability of Requirement Phase Design. The designed tool will be used to automate the process of mapping E-R Diagram into relational model and to generate (Data Definition Language) DDL statement for each relation. Keywords-R Diagram, SDLC, DDL

Testing Satellite on-board Software - A Model Based Approach

Today, testing on-board software consumes approx. 30% of the effort for a software project. Improvements in this area will help to save a significant amount of time and money. As discussed in the research community, model based approaches are a very promising solution to save costs while increasing software quality at the same time. Failure Detection, Isolation and Recovery (FDIR) is a significant part of today's flight software. Approx. 30% of the test effort is spent on this functionality. The basis for the FDIR is the failure mode effect analysis (FMEA). Therefore, the approach we present hereafter starts from a “traditional” text based FMEA document.

Spy: A flexible code profiling framework

Code profiling is an essential activity to increase software quality. It is commonly employed in a wide variety of tasks, such as supporting program comprehension, determining execution bottlenecks, and assessing code coverage by unit tests. Spy is an innovative framework to easily build profilers and visualize profiling information. The profiling information is obtained by inserting dedicated code before or after method execution. The gathered profiling information is structured in line with the application structure in terms of packages, classes, and methods. Spy has been instantiated on four occasions so far. We created profilers dedicated to test coverage, time execution, type feedback, and profiling evolution across version. We also integrated Spy in the Pharo IDE. Spy has been implemented in the Pharo Smalltalk programming language and is available under the MIT license.

Which Crashes Should I Fix First?: Predicting Top Crashes at an Early Stage to Prioritize Debugging Efforts

Many popular software systems automatically report failures back to the vendors, allowing developers to focus on the most pressing problems. However, it takes a certain period of time to assess which failures occur most frequently. In an empirical investigation of the Firefox and Thunderbird crash report databases, we found that only 10 to 20 crashes account for the large majority of crash reports; predicting these “top crashes” thus could dramatically increase software quality. By training a machine learner on the features of top crashes of past releases, we can effectively predict the top crashes well before a new release. This allows for quick resolution of the most important crashes, leading to improved user experience and better allocation of maintenance efforts.

A Mock-Up Tool for Software Component Reuse Repository

Software Reuse effectiveness can be improved by reducing cost and investment. Software reuse costs can be reduced when reusable components are easy to locate, adapt and integrate into new efficient applications. Reuse is the key paradigm for increasing software quality in the software development. This paper focuses on the implementation of software tool with a new integrated classification scheme to make classification build of software components and effective software reuse repositories to facilitate retrieval of software components depending upon user requirements.

Sharing efforts for modelling plant systems: from publications to reusable software components

Plant models become increasingly complex and their implementation often implies the use of advanced techniques in computer science. This evolution has been accompanied by the production of dedicated plant modelling tools, such as simulation platforms, that facilitate research in this field. However, much less sharing is observed for plant models themselves, that is for computer programs produced by scientists to address their specific questions. Yet, these programs could be highly valuable for other researchers, to avoid redundant development of similar code or to help non-specialists to simulate parts of a complex system. Model descriptions found in academic publications, even combined with code sources, are generally not sufficient for model reuse. Most difficulties come from the heterogeneity of language used, the structure of the programs, the download and installation procedures, the accessibility to the source code of the model, and the availability of documentation. The OpenAlea initiative (http://openalea.gforge.inria.fr) has been launched to address these problems by providing plant modellers with collaborative tools and guidelines to increase software quality, hence re-usability of their models. The Alinea pilot project further tested these concepts in a sample community of ecophysiologists and biophysicists. Based on this experience, we illustrate pros and cons of the approach and discuss future direction of progress. We foresee three steps towards a better re-usability of models: a better interoperability of existing tools and simulation platforms, the emergence of design patterns for plant modelling, and the definition of standardised data structures.

Checking the reliability of socket based communication software

Locating potential execution errors in software is gaining more attention due to the economical and social impact of software crashes. For this reason, many software engineers are now in need of automatic debugging tools in their development environments. Fortunately, the work on formal method technologies during the past 25 years has produced a number of techniques and tools that can make the debugging task almost automatic, using standard computer equipment and with a reasonable response time. In particular, verification techniques like model-checking that were traditionally employed for formal specifications of the software can now be directly employed for real source code. Due to the maturity of model-checking technology, its application to real software is now a promising and realistic approach to increase software quality. There are already some successful examples of tools for this purpose that mainly work with self-contained programs (programs with no system-calls). However, verifying software that uses external functionality provided by the operating system via API s is currently a challenging trend. In this paper, we propose a method for using the tool spin to verify C software systems that use services provided by the operating system thorough a given API. Our approach consists in building a model of the underlying operating system to be joined with the original C code in order to obtain the input for the model checker spin. The whole modeling process is transparent for the C programmer, because it is performed automatically and without special syntactic constraints in the input C code. Regarding verification, we consider optimization techniques suitable for this application domain, and we guarantee that the system only reports potential (non-spurious) errors. We present the applicability of our approach focusing on the verification of distributed software systems that use the API Socket and the network protocol stack TCP/IP for communications. In order to ensure correctness, we define and use a formal semantics of the API to conduct the construction of correct models.

A language for high-level description of adaptive web systems

Adaptive Web systems (AWS) are Web-based systems that can adapt their features such as, presentation, content, and structure, based on users’ behaviour and preferences, device capabilities, and environment attributes. A framework was developed in our research group to provide the necessary components and protocols for the development of adaptive Web systems; however, there were several issues and shortcomings ( e.g. low productivity, lack of verification mechanisms, etc.) in using the framework that inspired the development of a domain-specific language for the framework. This paper focuses on the proposal, design, and implementation of AWL, the Adaptive Web Language, which is used to develop adaptive Web systems within our framework. Not only does AWL address the existing issues in the framework, but it also offers mechanisms to increase software quality attributes, especially, reusability. An example application named PENS (a personalized e-News system) is explained and implemented in AWL. AWL has been designed based on the analysis of the adaptive Web domain, having taken into account the principles of reuse-based software engineering (product-lines), domain-specific languages, and aspect-oriented programming. Specially, a novel design decision, inspired by aspect-oriented programming paradigm, allows separate specification of presentation features in an application from its adaptation features. The AWL’s design decisions and their benefits are explained.

Controlled experimentation on adaptations of pair programming

The use of agile methods is growing in industrial practice due to the documented benefits of increased software quality, shared programmer expertise, and user satisfaction. These methods include pa...

A COLLABORATIVE SOFTWARE CODE INSPECTION: THE DESIGN AND EVALUATION OF A REPEATABLE COLLABORATION PROCESS IN THE FIELD

The use of software products in today's world has increased dramatically making quality an important aspect of software development. There is a continuous need to develop processes to control and increase software quality. Software code inspection is one way to pursue this goal. This paper presents a collaborative code inspection process that was designed during an action research study using Collaboration Engineering principles and techniques. Our inspection process was implemented as a sequence of thinkLets, chunks of facilitation skill, that were subsequently field tested in a traditional paper-based and Group Support System (GSS)-based environment. Four inspections were performed on four different pieces of software code in two different organizations. Results show that regardless of the implementation, the process was found to be successful in uncovering many major, minor, and false-positive defects in inspected pieces of code. Overall observations and feedback suggest that the collaborative inspection process was considered to be productive and satisfactory. GSS inspections were more effective, especially in terms of major defects. GSS inspections were also found to be more efficient. Finally, the GSS inspections outperformed the paper inspections from a practical perspective: logging and managing defects in a GSS was far superior.

Fault patterns in Matlab

Fault patterns are code idioms that may constitute faults. Software engineers have various program analysis techniques and tools to assist them in the detection of such patterns, resulting in increased software quality. End user programmers, however, often lack such support. In this paper we take a first step to address this limitation in the context of Matlab. First, we adapt fault patterns commonly used in other programming languages to Matlab. Second, we present a tool to detect such patterns in fifteen popular Matlab programs. Our results reveal that these simple and quickly identifiable patterns are commonly found in Matlab programs developed by end users and shared across the large Matlab community of end user programmers.

A Survey of Metrics for UML Class Diagrams.

The demand for increased software quality has resulted in quality being more of differentiator between products than it ever has been before. For this reason, software developers need objective and valid measures for use in the evaluation and improvement of product quality from the initial stages of development. Class diagrams are a key artifact in the development of object-oriented (OO) software because they lay the foundation for all later design and implementation work. It follows that emphasizing class diagram quality may significantly contribute to higher quality OO software systems. The primary aim of this work, therefore, is to present a survey, as complete as possible, of the existing relevant works regarding class diagram metrics. Thus, from works previously published, researchers and practitioners alike may gain broad and ready access to insights for measuring these quality characteristics. Another aim of this work is to help reveal areas of research either lacking completion or yet to undertaken.

Configurable data integration middleware system

This paper presents a new approach for generating configured and flexible middleware systems for integration of heterogeneous and distributed data. The configuration is based on the selection of an adequate set of database services components and flexibility is achieved by adopting framework techniques. A control model checks the configuration, manages the communication between components and dynamically schedules tasks. The objective is to build tailored integration middleware systems, using a minimum number of components. In addition, the use of framework allows for increased software quality and reduced development effort.

Assessing the practical benefits of formal methods for software development

We describe a case study where one software module of an existing physical access control system was re-developed using formal software development methods. Because of increased software quality and comparable development efforts, we are considering the use of formal methods for the future development of critical modules. Further results of this work include the identification of a critical property of the given requirements, as well as insights into overall requirements quality.

Object modelling languages: An evaluation and some key expectations for the future

Object modelling languages are graphical semidformal specification languages. They are tools to capture and formalise requirements in the earlier phases of software development, as well as providing support for describing designs, software architecture and even detailed implementations later in the process. One can consider these languages to have reached some level of maturity, especially because their precursors, the ObjectdOriented Analysis and Design methods, have now been used and tested intensively in industry for many years. In addition, these modelling languages have been the subject of many improvements by the scientific community. Nevertheless, some dissatisfaction persists. In this paper, we aim to redanalyse several parts of the deep structure of two leading object modelling languages: OML and UML, in order to show how they can really increase software quality. Their structure is based on metamodelling, which is the way the semantics of these two languages is expressed. This structure is also the source of a proliferation of modelling constructs (for example, different forms of inheritance associated with distinct notational elements) whose use must clearly influence, in particular, reusability – a key expectation in a software engineering process. More generally, we identify some deficiencies in these languages, which allows us to highlight some appropriate evolutionary paths. In discussing dynamic metamodelling and scalability, we specifically outline that a main current drawback is the difficulty of implementing these languages in ComputerdAided Software Engineering tools.

Social issues in the collection and use of software metric data position paper: Metrics: Promise vs. implementation

Ten years ago claims where made that the collection and use of software metric data would greatly improve the software development process and increase software quality. Today, after years of trying to establish metric programs, we have learned a great deal about the cultural and technical changes necessary to establish a metric program. The author's position is that social issues are the major difficulty in initiating a metric program. People fear reporting numbers to management. The author believes that social difficulties can be overcome with education and successful use of metric data.