Cutting errors in software design

Information systems are now widely used to automate the manage and execution of judicial business processes. However, the design of a judicial information system is in nature complex, and it is difficult to ensure its correctness and trustworthiness, including the security and integrity of the data about the evidence and the conformance to laws, regulation and rules of practice, in the design and the execution of judicial workflows. In this paper, we focus on how to improve the correctness and trustworthiness of the information system through the development of models of workflows at different levels of abstraction and in different degrees of formality. The final model before the implementation is a formal model which can be formally validated and its implementation is provable correctly. Our proposed method starts with informal use case modeling and gradually transforms to formal Communicating Sequential Process (CSP) modeling. To transform use case models into a model in CSP, the specified use cases are refined into use case sequence diagrams and the relationships between use cases are represented as the case model. Our method combine the advantages of informal models and formal models. It support the modeler to communicate with domain users and experts. With the formal model in CSP, designers are capable of identifying errors during designing of the workflow, and thus able to correct them before the implementation phase. We illustrate the method with the workflow of the civil litigation in China as a case study.

With the commercial development of multicore processors, the challenges of writing multithreaded programs to take advantage of these new hardware architectures are becoming more and more pertinent. Concurrent programming is necessary to achieve the performance that the hardware offers. Traditional approaches present concurrency as an advanced topic: they have proven difficult to use, reason about with confidence, and scale up to high levels of concurrency. This article reviews process-oriented design , based on Hoare's algebra of Communicating Sequential Processes (CSP), and proposes that this approach to concurrency leads to solutions that are manageable by novice programmers; that is, they are easy to design and maintain, that they are scalable for complexity, obviously correct , and relatively easy to verify using formal reasoning and/or model checkers. These solutions can be developed in conventional programming languages (through CSP libraries) or specialized ones (such as occam-π) in a manner that directly reflects their formal expression. Systems can be developed without needing specialist knowledge of the CSP formalism, since the supporting mathematics is burnt into the tools and languages supporting it. We illustrate these concepts with the Santa Claus problem , which has been used as a challenge for concurrency mechanisms since 1994. We consider this problem as an example control system, producing external signals reporting changes of internal state (that model the external world). We claim our occam-π solution is correct-by-design , but follow this up with formal verification (using the FDR model checker for CSP) that the system is free from deadlock and livelock, that the produced control signals obey crucial ordering constraints, and that the system has key liveness properties.

<div class="htmlview paragraph">Software Systems Safety has become a widely recognized issue in recent years due to the occurrence of several catastrophics directly attributed to software failures or design errors in software controlled systems. In many other instances, incidents that have been attributed to operator error may have in fact been caused by or contributed to by poor software design or implementation. The safety analysis of the operator, user and maintainer interfaces is essential if we are to design software controlled systems that both minimize and tolerate (safely) human errors. This paper will discuss the software systems safety issue and the various areas of human errors that affect the discipline. This paper will also discuss techniques used in software systems safety and the necessity for an early, integrated approach to both software systems safety and Human Factors.</div>

The Software design process involves a high degree of human interaction and design artifacts creation by software engineers. Software designers use their experience to make assumptions and decisions. Therefore, the software design is prone to errors that lead to a bad quality software. Software engineering literature focuses on software errors and failures. This research relates the concept of human and organizational errors to the errors committed by software engineers during the software design phase to improve software quality. The authors performed a systematic literature review (SLR) of the software engineering to identify software design errors and later classify them. The outcome is a software design errors taxonomy that provides errors and a way to classify those errors based on their similarities and origin. This research proposes a guide to comprehend common software design errors. The guide will allow software engineers to focus and create robust software design. The guide also provides a structured approach to detect software design errors upfront during the software design inspection process. Software development organizations can use this awareness to develop countermeasures to help with error prevention, thereby improving the overall software quality.

Software has become a vital factor in the fourth industrial revolution. Owing to the increase in demand for software products in various fields (big data, artificial intelligence, the Internet of Things, etc.), the software industry has expanded more than ever before. Therefore, software reliability has become very important, and efforts are being made to increase it. One of these efforts is the development of software reliability models (SRMs). SRMs have been studied for a long time as a model that predicts software reliability by using the number of software faults. Software failures can occur for several reasons, including independent software faults such as code errors and software hangs, as well as dependent cases where code errors lead to other software faults. Recently, due to the diversity of software operating environments, software faults are more likely to occur in a dependent manner, and, for this reason, they are likely to increase rapidly from the beginning and progress slowly to the maximum number thereafter. In addition, many large companies have focused on open-source software (OSS) development, and OSS is being developed by many users. In this study, we propose a new SRM that considers the number of finite faults and dependent faults, and examine the goodness-of-fit of a new SRM and other existing non-homogeneous Poisson process models based on the OSS datasets. Through numerical examples, the proposed model demonstrated a significantly better goodness-of-fit when compared to other existing models, and it also exhibited better results on the newly proposed integrated criteria.

A great deal of research in software engineering focuses on understanding the dynamic nature of software systems. Such research makes use of automated instrumentation and profiling techniques after fact, i.e., without considering domain knowledge. In this paper, we turn our attention to another source of dynamic information, i.e., the Communicated Information (CI) about the execution of a software system. Major examples of CI are execution logs and system events. They are generated from statements that are inserted intentionally by domain experts (e.g., developers or administrators) to convey crucial points of interest. The accessibility and domain-driven nature of the CI make it a valuable source for studying the evolution of a software system. In a case study on one large open source and one industrial software system, we explore the concept of CI and its evolution by mining the execution logs of these systems. Our study illustrates the need for better trace ability techniques between CI and the Log Processing Apps that analyze the CI. In particular, we find that the CI changes at a rather high rate across versions, leading to fragile Log Processing Apps. 40% to 60% of these changes can be avoided and the impact of 15% to 50% of the changes can be controlled through the use of the robust analysis techniques by Log Processing Apps. We also find that Log Processing Apps that track implementation-level CI (e.g., performance analysis) are more fragile than Log Processing Apps that track domain-level CI (e.g., workload modeling), because the implementation-level CI is often short-lived.

Formal description of network behavior is the important part in network management. But some problems have not yet to be adequately addressed are the semantic and behavioral aspects of composition in this domain. Therefore a formal description method was presented to network behavior. The method includes a simple formal language, and its semantic was described by CSP. The formal language has graphical syntax with topology style. And it also has some characters that are suitable for the formal research and analysis about some problems in network management. Consequently, the method can be used to provide precise formal description and analysis about network behavior. And a reliable mathematical foundation is also provided for the correctness and validity of software system design.

Systems are becoming increasingly complex in the software industry, which also makes them more prone to failure. Ensuring software quality through rigorous testing is crucial, but this task still needs to be improved and more manageable because it still consumes significant parts of the project budget. Automation is a critical factor in improving testing efficiency, with new methodologies and tools being developed continuously. Machine Learning has attracted considerable interest in several areas over the last ten years, driven by advances in computing power and the ability to manage large volumes of data. Tricorder is a testing methodology designed to detect potential software faults by analyzing changes in the resource consumption behavior of the computing system under test. Unsupervised machine learning provided by DAMICORE characterizes resource consumption behavior. The methodology used by DAMICORE is based on a pipeline of three main steps. The pipeline uses Normalized Compression Distance (NCD) to generate a distance matrix, the Neighbor-Joining algorithm to build a phylogenetic tree, and the Fast Newman method for community detection, which is essential for data clustering. DAMICORE monitors and identifies anomalies in resource usage patterns, such as CPU, memory, and I/O, to indicate the presence of software faults. This project studies the impact generated by DAMICORE in the detection of software faults provided by Tricorder in the context of agglomerative clustering and phylogenetic trees, testing several techniques adapted to DAMICORE. The literature review on Machine Learning applied to Software Testing highlighted that the most widely studied techniques for agglomerative clustering are based on Single, Complete, and Average (UPGMA) Linkages. Neighbor-joining and UPGMA are prominent in the construction of phylogenetic trees. To achieve the project objectives, we consolidated the theoretical foundations, followed by an in-depth review of the state of the art and the specific methodologies of Tricorder and DAMICORE. We then systematically designed and executed a series of experiments, analyzing the generated results. The project demonstrated the potential of using Levenshtein distance, leveraging the network topology for community detection, and incorporating all system metrics into a single analysis. These approaches yielded better results in our context than other techniques found in the literature. NCD and Neighbor-Joining have significant limitations, especially due to their high computational demands, which hinder their practical application in more extensive and complex projects. The improvements introduced in this project should improve DAMICOREs accuracy in detecting software faults. The results of this project contribute to the state-of-the-art application of Machine Learning to Software Testing and reinforce Tricorders position in the Software Testing community.

Software design is one of the most important and key activities in the system\ndevelopment life cycle (SDLC) phase that ensures the quality of software.\nDifferent key areas of design are very vital to be taken into consideration\nwhile designing software. Software design describes how the software system is\ndecomposed and managed in smaller components. Object-oriented (OO) paradigm has\nfacilitated software industry with more reliable and manageable software and\nits design. The quality of the software design can be measured through\ndifferent metrics such as Chidamber and Kemerer (CK) design metrics, Mood\nMetrics & Lorenz and Kidd metrics. CK metrics is one of the oldest and most\nreliable metrics among all metrics available to software industry to evaluate\nOO design. This paper presents an evaluation of CK metrics to propose an\nimproved CK design metrics values to reduce the defects during software design\nphase in software. This paper will also describe that whether a significant\neffect of any CK design metrics exists on total number of defects per module or\nnot. This is achieved by conducting survey in two software development\ncompanies.\n

The development of humanlike service robots which interact socially raises a new question: How can we make good interaction content for such robots? Domain experts specializing in the target service have the knowledge for making such content. Yet, while they can easily engage in good face-to-face interactions, we found it difficult for them to prepare conversational content for a robot in written form. Instead, we propose involving experts as teleoperators in an iterative development process in which the expert develops content, teleoperates a robot using that content, and then revises the content based on that interaction. We propose a software system and design guidelines to enable such an iterative design process. To validate these solutions, we conducted a comparison experiment in the field, with elderly volunteer guides teleoperating a robot at a tourist information center in Nara, Japan. The results showed that our system and guidelines enabled domain experts with no robotics background to create better interaction content and conduct better interactions than domain experts without our system.

Sustainability incorporation within the field of Software Engineering is an emerging research area. Sustainability, from an academic perspective, has been addressed to a large extent. However, when it comes to the software industry, the topic has not received much-needed attention. Software, being designed and developed in the industry, can benefit society at large, if sustainability is taken into account by the software professionals during the software design and development process. To develop a sustainable software application, knowledge and awareness about sustainability by professional software developers is one of the key elements. This study is an attempt to examine sustainability knowledge, importance, and support from the perspective of South Asian software professionals. Additionally, this study also proposes sustainability guidelines for certain software applications and also a catalog for the identification of sustainability requirements for different software applications. The queries such as ‘What does sustainability mean to a professional software developer?’, ‘How does the software industry identify sustainability requirements?’, ‘How do software developers incorporate the sustainability parameters within software during software development?’, and many other such queries are addressed in this study. To achieve this goal, a survey was carried out among 221 industry practitioners involved in software projects in various application domains such as banking, finance, and management applications. The results pinpoint that even though sustainability is deemed important by 91% of practitioners, still there is a lack of understanding regarding sustainability incorporation in software development. A total of 48% of professionals often misunderstand “Green software” as “sustainable software”. The technical aspect of sustainability is considered most important by professionals (67%) as well as companies (77%). One of the key findings of this study is that 92% of software practitioners are not able to identify sustainability requirements for software applications. The outcomes of the study may be regarded as an initial attempt towards how sustainability is comprehended in software by the South Asian software industry.

This paper examines a set of abstract, top‐level principles and subprinciples collected from the literature to determine their usefulness in enabling the avoidance, survival, and recovery from disruptions caused by threats of various sources. The principles are compared to concrete solutions recommended by domain experts in various case studies and to the actual events in those case studies. Also examined are the limitations, conflicts, and vulnerabilities that may be apparent when concrete solutions are created from these principles. The systems considered are physical, organizational, and procedural systems. Examples include cases from fire protection, aviation, railways, and power distribution domains. Threats examined include terrorist attacks, natural disasters, and human and design error. Each principle is found to apply to different phases of the disruption cycle surrounding an encounter with a threat. It is found that principles, in general, cannot be applied singly to a system but must be combined with other principles to enable resilience. System developers in various domains can use the principles to create concrete solutions to characterize a particular system, model that solution, and determine the degree of recovery of the system from a specified threat. ©2012 Wiley Periodicals, Inc. Syst Eng 16

This work presents our approach to formally model the Swiftaid system design, a digital platform that enables donors to automatically add Gift Aid to donations made via card payments. Following principles of Behaviour-Driven Development, we use Gherkin to capture requirements specified in legislation, specifically the UK Charity (Gift Aid Declarations) Regulations 2016. The Gherkin scenarios provide a basis for subsequent formal modelling and analysis using Event-B, Rodin and ProB. Interactive model simulations assist communication between domain experts, software architects and other stakeholders during requirements capture and system design, enabling the emergent system behaviour to be validated. Our approach was employed within the development of the real Swiftaid product, launched by Streeva in February 2019. Our analysis helped conclude that there was not a strong enough business case for one of the features, whichwas shown to provide nominal user convenience at the expense of increased complexity. This work provides a case study in allying formal and agile software development to enable rapid development of robust software.

The authors have designed a system functional requirement (SFR) specification processor using a knowledge-based system approach in conjunction with other artificial intelligence techniques, this processor can be used for a variety of software systems. Domain-specific expert knowledge is defined for each software system application. The adopted specification language can easily be read by a variety of people such as customers, managers, requirement writers, software designers, and the test team. The processor, for a given software system application, not only checks for consistency, completeness, nonredundancy, and nonambiguity, but also uses domain-specific expert knowledge to verify that the SFR specification document is correct from the domain expert's point of view. To illustrate the proposed approach, the authors give an example of a component of a telephone switching system and the processor system methodology.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

All software system fails. However, as more defects the development team can identify and remove as lower will be the probability of software to fail. Identifying and removing defects throughout the software development process represent an important approach to improve software quality. There is evidence about the feasibility, efficiency and efficacy of using software inspections to support the identification of defects. Besides their low cost, the performance of inspections can be positively influenced by the technique used to detect defects. Despite all these benefits, the use of inspections is not common place in the software industry. Therefore, this Quatic 2014 keynote speech intends to discuss the benefits of Software Inspections (the method and techniques) and their use in software projects.