Software Design Quality Research Articles

Fathom: a technology-enhanced learning environment for teaching-learning of expand-reduce skills in software design

Software design problems are often characterized as ill-structured because the requirements are not clearly defined. These problems offer various solution paths and the criteria used to select the solution may not be known initially. The expertise and experience of designers play a crucial role in determining the quality of software design. Less experienced designers often tend to prematurely narrow down their options to a single solution without fully exploring the problem-solution space. This tendency has a negative impact on the overall quality of software design. Studies have shown that systematically expanding the problem space before reducing to problem formulation and exploring the solution space before reducing it to a single solution (expand-reduce skills) improves the quality of the design. We have designed and developed a technology-enhanced learning environment (TELE) named Fathom for scaffolding expand-reduce (ER) skills in software design problems in a data structures course. In this paper, we present three cycles of design, development, and evaluation of Fathom based on the design-based research (DBR) approach. In the first DBR cycle, we identified and evaluated Fathom’s pedagogical features in learning ER skills. In the second cycle of DBR, the aim was to improve the design of Fathom for the learning and transfer of ER skills. Fathom was revised in the third cycle of the DBR to scaffold metacognitive skills. The main contribution of this research is pedagogical design for facilitating the learning of expand-reduce skills in solving software design problems.

A Component Selection Framework of Cohesion and Coupling Metrics

Component-based software engineering is concerned with the development of software that can satisfy the customer prerequisites through reuse or independent development. Coupling and cohesion measurements are primarily used to analyse the better software design quality, increase the reliability and reduced system software complexity. The complexity measurement of cohesion and coupling component to analyze the relationship between the component module. In this paper, proposed the component selection framework of Hexa-oval optimization algorithm for selecting the suitable components from the repository. It measures the interface density modules of coupling and cohesion in a modular software system. This cohesion measurement has been taken into two parameters for analyzing the result of complexity, with the help of low cohesion and high cohesion. In coupling measures between the component of inside parameters and outside parameters. The final process of coupling and cohesion, the measured values were used for the average calculation of components parameter. This paper measures the complexity of direct and indirect interaction among the component as well as the proposed algorithm selecting the optimal component for the repository. The better result is observed for high cohesion and low coupling in component-based software engineering.

DEPICTER: A Design-Principle Guided and Heuristic-Rule Constrained Software Refactoring Approach

Software refactoring is one of the most significant practices in software maintenance as the quality of software design tends to deteriorate during software evolution. But, refactoring software is a very challenging task as it requires a holistic view of the entire software system. To this end, recent studies introduced search-based algorithms to facilitate software refactoring. However, they still have the following major limitations: 1) the searched solutions may violate the design principles as their fitness functions do not directly reflect the degree of software’s compliance with design principles; 2) most approaches start the searching process from a completely random initial population, which may lead to unoptimal solutions. In this article, we aim to develop effective search-based refactoring approach to recommend better refactoring activities for developers which can improve the degree of software’s compliance with design principles as well as the software design quality. We propose <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">DEPICTER</monospace> , a design-principle guided and heuristic-rule constrained software refactoring recommendation approach. In particular, <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">DEPICTER</monospace> uses non-dominated sorting genetic algorithm (NSGA)-II genetic algorithm and employs design-principle metrics as fitness functions. Besides, <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">DEPICTER</monospace> leverages heuristic rules to improve the quality of initial population for subsequent generic evolution. Our evaluations, based on four widely used systems, show that <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">DEPICTER</monospace> is effective for guiding the development of better refactoring models in practice.

A Comparison of Recent Requirements Gathering and Management Tools in Requirements Engineering for IoT-Enabled Sustainable Cities

The Internet of Things (IoT) is a paradigm that facilitates the proliferation of different devices such as sensors and Radio Frequency Identification (RFIDs) for real-time applications such as healthcare and sustainable cities. The growing popularity of IoT opens up new possibilities, and one of the most notable applications is related to the evolving sustainable city paradigm. A sustainable city is normally designed in such a way to consider the environmental impact and a social, economic, and resilient habitat for existing populations without compromising the ability of future generations to experience the same, while the process of managing project requirements is known as requirements management. To design a high-quality project, effective requirements management is imperative. A number of techniques are already available to perform the requirement gathering process, and software developers apply them to collect the requirements. Nevertheless, they are facing many issues in gathering requirements due to a lack of literature on the selection of appropriate methods, which affects the quality of the software. The software design quality can be improved by using requirements capture and management techniques. Some tools are used to comprehend the system accurately. In this paper, a qualitative comparison of requirements-gathering tools using Artificial Intelligence (AI) and requirements-management tools is presented for sustainable cities. With all the tools and techniques available for capturing and managing requirements, it has been proven that software developers have a wide range of alternatives for selecting the best tool that fits their needs, such as chosen by the AI agent. This effort will aid in the development of requirements for IoT-enabled sustainable cities.

Decision-Making Principles for Better Software Design Decisions

Software design is about making decisions. The quality of design decisions influences the quality of software design. This article describes nine decision-making principles to give software designers a systematic approach for decision making.

Methodological foundation for improving the quality of intelligent decision-making system software

On the basis of a detailed analysis, existing terminological interpretations of the concept of "software quality" have been generalized, conclusions are drawn about the correspondence of the terms used to assess the quality of general software in the process of assessing the quality of software of intelligent decision-making systems (IDMS). It has been proved that the quality of the IDMS software is a complex multi-criteria indicator that takes into account not only the performance of the individual software module as a subsystem, but also the causal relationships of the elements of the software system itself. The main differences in software quality assessment between the functional and formal approaches are shown. The structure of the criterion of guarantor capacity of decision-making systems software has been investigated and conclusions have been drawn on the influence of its main components on the evaluation of IDMS software and on the provision of reliable computing process. On the basis of the analysis of the list of attributes and the quality metric of the IDMS software, it is established that the guarantee is determined by the reliability of the software structure itself and is characterised by the restoration of the functional state after failures or failures. The interrelationship and influence of IDMS software design quality indicators on the characteristics and sub-characteristics of the IDMS software is established, an example of the interrelationship between characteristics (factors) and quality indicators, the method of measuring quality indicators and design processes is given. On the basis of the conducted research, IDMS software denial regimes have been defined and their impact on the decision-making process has been shown. Detailed classes of failures and their influence on compliance of IDMS software with the task of development are shown. It has been shown that the reliability of IDMS is a dynamic concept, manifested in time, and is strongly dependent on the presence / absence of defects in the interaction. A detailed analysis of methods of software quality assurance and control has been carried out, and conclusions have been drawn on the possibility of their application IDMS software. The maturity model of the IDMS software has been improved and validated, and the maturity structure of the software as an indicator of the quality of the IDMS has been introduced.

Restructuring Object-Oriented Software Systems Using Various Aspects of Class Information

Frequent modifications in a software system generally deteriorate the design of the source code and consequently increase the complexity of the system. In object-oriented software, one of the symptoms of design degradation is that the package structure of the source code drifts away from design principles. To improve the deteriorated design, systems are generally restructured by reorganizing the classes into packages based on good design principles. Coupling and cohesion are the two important package design principles widely used to assess software design quality. Most of the existing package restructuring approaches use either structural, lexical, or change history class information to compute coupling and cohesion of software system. Moreover, these approaches compute coupling and cohesion without considering multiple dimensions of structural, lexical, and change history information. In this article, we utilize different types of structural, lexical and change history class information and integrate them as per their relative importance to compute coupling and cohesion. To automate the restructuring process, we formulate the restructuring problem as a multi-objective optimization problem and solve it by using non-dominated sorting genetic algorithm (NSGA-II). The proposed approach is applied to five object-oriented software applications. The obtained restructuring is compared with authoritative restructuring and restructuring suggested by external developers. The obtained restructuring is also compared with some existing multi-objective software restructuring approaches. Overall, findings indicate that the proposed approach can be a good approach to improve the design of software systems whose quality is under suspicion.

Pattern detection and design rationale traceability: an integrated approach to software design quality

Design rationale is the synthesis of the structure that is consistent with the model of an artefact, decisions, alternative approaches, and the reasoning behind it. Hence, bypassing it will result in poor quality systems engineering. Ambiguous representation of design rationale goals is just one of the many limitations that contributes to the intricacy of design patterns, thereby this research aims to introduce an approach to support the structuring, evaluation, and analysis of design patterns. The authors have proposed a method and implemented an associated tool with a mechanism that validates the class relationships and properties of design patterns comprehensively, resulting in a reliable pattern detection result. The preliminary results of the proposed research show that although detection and evaluation of a design pattern require some overhead using the approach, it does contribute to the confidence of the developers and gives affirmation that the design pattern implemented in the source code achieves its defined rationale goals based on the gang of four definition of design patterns through the reliable pattern detection output and straightforward evaluation result. The conclusion could be drawn that through the proposed approach, the preliminary result resolves the intricacy of design rationale traceability while achieving software quality is permissible.

Exploring the Quality Improvement in Small Scale Project Using Aspect-Oriented Design

Aspect-oriented software development (AOSD) seeks to renovate the software quality by use of alteration to the design in object-oriented based systems. Each system component has been divided into numbers of modules and arranges a design in a way that the module has not crosscut to each other. A module is a collection of block of codes, whose role is to restrict and conceal the design definition. This type of behavior is known as the Separation of Concerns (SoC). AOP helps programmers for separating crosscutting concerns. It can be helpful at better modularizing system, the problem with complex system is that the component require different, crosscutting descriptions at different levels and need maintenance too. In this paper, a study was conducted to analyses quality in aspect-oriented software design. This paper also explores varieties of existing metrics related to AOP also and will discuss in detail with comparison of OOPs using small scale projects that how the new programming paradigm design effects on quality of the software.

EMPIRICALLY VALIDATED SIMPLICITY EVALUATION MODEL FOR OBJECT ORIENTED SOFTWARE

Software program developers need to go from beginning to ending and understand source code of the program and other software attributes. The software complexities and length of the program exceedingly affects many design level quality attributes, specifically Simplicity, Testability and software Maintainability. Incomplete design of any software generally leads to misunderstanding and ambiguities and therefore to gives faulty design and development results. This is mainly seeming and appears owing to the absence of it’s an appropriate observation, design and development control. However, high level design and program simplicity are very necessary and one of the vital attributes of the system development cycle. This research paper highlights the impact and significance of design level software simplicity in common and as a one of the most useful key factor or index of software quality assurance and testing. In this research work principally there are three major efforts are made. As a first contribution, a valuable relationship between software design quality factor simplicity and related object oriented design properties, this has been set up. In the second contribution, using design level corresponding metrics a simplicity evaluation model for object oriented software is developed. Subsequently, the developed simplicity model has been rationally authenticated by means of experimental data try-out.

An aggregated coupling measure for the analysis of object-oriented software systems

Coupling is a fundamental property of software systems which is strongly connected with the quality of software design and has high impact on program understanding. The coupling between software components influences software maintenance and evolution as well. In order to ease the maintenance and evolution processes it is essential to estimate the impact of changes made in the software system, coupling indicating such a possible impact. This paper introduces a new aggregated coupling measurement which captures both the structural and the conceptual characteristics of coupling between the software components. The proposed measure combines the textual information contained in the source code with the structural relationships between software components. We conduct several experiments which underline that the proposed aggregated coupling measure reveals new characteristics of coupling and is also effective for change impact analysis.

Efficient refactoring scheduling based on partial order reduction

Anti-patterns are poor solutions to design problems that make software systems hard to understand and to extend. Components involved in anti-patterns are reported to be consistently related to high changes and faults rates. Developers are advised to perform refactoring to remove anti-patterns, and consequently improve software design quality and reliability. However, since the number of anti-patterns in a system can be very large, the process of manual refactoring can be overwhelming. To assist a software engineer who has to perform this task, we propose a novel approach RePOR (Refactoring approach based on Partial Order Reduction). We perform a case study with five open source systems to assess the performance of RePOR against two well-known metaheuristics (Genetic Algorithm, and Ant Colony Optimization), one conflict-aware refactoring approach and, a new approach based on sampling (Sway). Results show that RePOR can correct a median of 73% of anti-patterns (10% more than existing approaches) with a significant reduction in effort (measured by the number of refactorings applied) ranging from 69% to 85%, and a reduction of execution time ranging between 50% and 87%, in comparison to existing approaches.

Improving Cohesion of a Software System by Performing Usage Pattern Based Clustering

Increasing the software design quality is a key research challenge in object-oriented software development system. Cohesion is one of the key spect that helps to evaluate the quality and modularity of a software system at the design level. It helps to create software components that are directly reusable to the industry because of their less dependence on other components. In this paper, a new cohesion metric for object-oriented software, named as Usage Pattern Based Cohesion (UPBC), is proposed which is computed at the module level. This paper considers class as a module initially and subsequently group of classes (i.e. a package) is considered as a module with an aim of improving overall cohesion. This metric utilizes the Frequent Usage Patterns (FUP) extracted from different member functions interactions to capture the cohesiveness of the module. Further, the measured cohesion value is used to perform clustering of modules in order to increase cohesion and decrease coupling among modules simultaneously. The clustering is performed by using a newly proposed clustering algorithm called FUPClust (Frequent Usage Pattern based Clustering) based on FUP interactions among modules. The proposed approach is applied to two Java software systems and the results obtained show a significant improvement in the cohesiveness of the software system.

Threshold design for cohesion and coupling metrics using K-means clustering Algorithm

As open source systems are becoming popular these days, there is more and more pressure on development teams to produce high-quality software. The quality of system (QoS) suffers even after undergoing testing; code smells still remain in the system. Various studies have been focusing on the relationship between metrics and code smells of class. Studies show that various metrics metric have been proposed to check the design quality of software during the development phase. A code smell is a suggestion or the description of an indication that something has gone wrong your code. Refactoring is done to clean the code and to decrease the chance of presenting the bugs in code. In this paper, describee is carried out to examine the relationship between cohesion and coupling metric and bad code smell for the open source code of ArgoUML four versions 0.24, 0.28, 0.30 and 0.34. Cohesion and coupling metrics design is done with the help of SourceMeter tool. PMD is used to collect all the bad code smell which are affecting the class. After that used technique k-means clustering, are used to find the threshold. In this work, it is proposed to use a clustering and metrics threshold based software bad code smell prediction approach and explore it on the dataset of ArgoUML versions. Clustering techniques have more importance in data mining especially when the data size is very large. Further, in this paper, the k-means algorithm has been applied for predicting code smells in program modules. Predicted models for one version are applied on other versions to check their accuracy. The results of the analysis are then used to conduct code smell classification based on the accuracy of one ArgoUML version and compared against the result of another version of ArgoUML.

Recognising object-oriented software design quality: a practitioner-based questionnaire survey

Design quality is vital if software is to be maintainable. What practices do developers actually use to achieve design quality in their day-to-day work and which of these do they find most useful? To discover the extent to which practitioners concern themselves with object-oriented design quality and the approaches used when determining quality in practice, a questionnaire survey of 102 software practitioners, approximately half from the UK and the remainder from elsewhere around the world was used. Individual and peer experience are major contributors to design quality. Classic design guidelines, well-known lower level practices, tools and metrics all can also contribute positively to design quality. There is a potential relationship between testing practices and design quality. Inexperience, time pressures, novel problems, novel technology, and imprecise or changing requirements may have a negative impact on quality. Respondents with most experience are more confident in their design decisions, place more value on reviews by team leads and are more likely to rate design quality as very important. For practitioners, these results identify the techniques and tools that other practitioners find effective. For researchers, the results highlight a need for more work investigating the role of experience in the design process and the contribution experience makes to quality. There is also the potential for more in-depth studies of how practitioners are actually using design guidance, including Clean Code. Lastly, the potential relationship between testing practices and design quality merits further investigation.

Best Editorial Members in Journal of Biology and Today's World During 2016-2017

We are proud that with the cooperation and efforts of the editorial members of JBTW, this journal was successful be indexed in the Scopus in 2016. This journal is an Iranian Journal that despite no support from the Iranian government could continue its activities firmly and in a high quality way. All researchers in the world are invited to submit their valuable manuscripts in the field of biomedical sciences to this journal. Editorial members of this journal are doing their utmost to have high quality referees and publication. It should be noted, now also this journal in terms of quality in infrastructure software, management and publication design is beyond of all developing countries. This report is provided for the members that have been most cooperative in this biomedical journal.

On the use of developers’ context for automatic refactoring of software anti-patterns

A novel automated refactoring approach that takes into account task context.A large scale case study showing the effectiveness of the proposed approach in two scenarios: root-canal and floss refactoring.Evaluation of the design quality of refactored solutions using a state-of-the-art quality model QMOOD. Anti-patterns are poor solutions to design problems that make software systems hard to understand and extend. Entities involved in anti-patterns are reported to be consistently related to high change and fault rates. Refactorings, which are behavior preserving changes are often performed to remove anti-patterns from software systems. Developers are advised to interleave refactoring activities with their regular coding tasks to remove anti-patterns, and consequently improve software design quality. However, because the number of anti-patterns in a software system can be very large, and their interactions can require a solution in a set of conflicting objectives, the process of manual refactoring can be overwhelming. To automate this process, previous works have modeled anti-patterns refactoring as a batch process where a program provides a solution for the total number of classes in a system, and the developer has to examine a long list of refactorings, which is not feasible in most situations. Moreover, these proposed solutions often require that developers modify classes on which they never worked before (i.e., classes on which they have little or no knowledge). To improve on these limitations, this paper proposes an automated refactoring approach, ReCon (Refactoring approach based on task Context), that leverages information about a developers task (i.e., the list of code entities relevant to the developers task) and metaheuristics techniques to compute the best sequence of refactorings that affects only entities in the developers context. We mine 1705 task contexts (collected using the Eclipse plug-in Mylyn) and 1013 code snapshots from three open-source software projects (Mylyn, PDE, Eclipse Platform) to assess the performance of our proposed approach. Results show that ReCon can remove more than 50% of anti-patterns in a software system, using fewer resources than the traditional approaches from the literature.

A new method for constructing and reusing domain specific design patterns: Application to RT domain

Domain specific design patterns capture domain knowledge and provide solutions of non trivial design problems in a specific domain. Their application improves considerably the quality of software design. In order to benefit from these advantages and to reinforce the application of these patterns, we provide, in this paper, new processes and tools for the development and the instantiation of domain specific design patterns, especially those intended for real-time domain.Initially, we propose a pattern development process that guides pattern developers in the construction of patterns. The proposed process defines unification rules that apply a set of comparison criteria on various applications in the pattern domain. This process is illustrated through the design of the controller pattern. Moreover, we propose a process guiding the application designers in pattern instantiation based on model transformation. Finally, the proposed RT patterns and their development process are evaluated by calculating quality metrics and comparing the applications designed with our RT patterns and others developed by experts without the use of our patterns.

Model-driven synthesis of formally precise, stylized software architectures

Abstract Reliably producing software architectures in selected architectural styles requires significant expertise yet remains difficult and error-prone. Our research goals are to better understand the nature of style-specific architectures, and relieve architects of the need to produce such architectures by hand. To achieve our goals, this paper introduces a formally precise approach to separate architectural style design decisions from application-specific decisions, and then uses these separate decisions as inputs to an automated synthesizer. This in effect supports a model-driven development (MDD) approach to architecture synthesis with style as a separate design variable. We claim that it is possible to formalize this separation of concerns, long implicit in software engineering research; to automatically synthesize style-specific architectures; and thereby to improve software design productivity and quality. To test these claims, we employed a combination of experimental systems and case study methods: we developed an MDD tool and used it to carry out case studies using Kitchenham’s methods. Our contributions include: a theoretical framework formalizing our separation of concerns and synthesis approach; an MDD framework, Monarch; and results of case studies that we interpret as supporting our claims. This work advances our understanding of software architectural style as a formal refinement; makes application descriptions an explicit subject of study; and suggests that synthesis of architectures can improve software productivity and quality.

Design quality of Mobile trading system application software for Smartphones

Mobile trading system is financial software for Smartphones that enables investors to make their buy or sell from a mobile phone that has internet connectivity. The application helps the investors to do their financial tasks from anywhere and anytime. The penetration of Smartphones and internet usage has made more and more people use this application. Performance of the application depends on the quality of the app. Similar to earlier studies of website quality (WebQual) and Smartphone application quality (AppQual), this paper looks at developing a scale for measuring the design quality of the mobile trading application software for the Smartphones.