Critical Software Research Articles

Actionable Analytics for Strategic Maintenance of Critical Software: An Industry Experience Report

Actionable Analytics for Strategic Maintenance of Critical Software: An Industry Experience Report

Comparison of the FMEA and STPA safety analysis methods\u2013a case study

As our society becomes more and more dependent on IT systems, failures of these systems can harm more and more people and organizations. Diligently performing risk and hazard analysis helps to minimize the potential harm of IT system failures on the society and increases the probability of their undisturbed operation. Risk and hazard analysis is an important activity for the development and operation of critical software intensive systems, but the increased complexity and size puts additional requirements on the effectiveness of risk and hazard analysis methods. This paper presents a qualitative comparison of two hazard analysis methods, failure mode and effect analysis (FMEA) and system theoretic process analysis (STPA), using case study research methodology. Both methods have been applied on the same forward collision avoidance system to compare the effectiveness of the methods and to investigate what are the main differences between them. Furthermore, this study also evaluates the analysis process of both methods by using a qualitative criteria derived from the technology acceptance model (TAM). The results of the FMEA analysis were compared to the results of the STPA analysis, which were presented in a previous study. Both analyses were conducted on the same forward collision avoidance system. The comparison shows that FMEA and STPA deliver similar analysis results.

Blockchain: properties and misconceptions

The purpose of this article is to clarify current and widespread misconceptions about the properties of blockchain technologies and to describe challenges and avenues for correct and trustworthy design and implementation of distributed ledger system (DLS) or Technology (DLT).,The authors contrast the properties of a blockchain with desired, however emergent, properties of a DLS, which is a complex and distributed system. They point out and justify, with facts and analysis, current misconceptions about the blockchain and DLSs. They describe challenges that these systems will need to address and possible solution avenues for achieving trustworthiness.,Many of the statements that have appeared on the internet, news and academic articles, such as immutable ledger and exact copies, may be misleading. These are desired emergent properties of a complex system, not assured properties. It is well-known within the distributed systems and critical software community that it is extremely hard to prove that a complex system correctly and completely implements emergent properties. Further research and development for trustworthy DLS design and implementation is needed, both practical and theoretical.,This is the first known published attempt at describing current misconceptions about blockchain technologies. Further collaborative work, discussions, potential solutions, evaluations, resulting publications and verified reference implementations are needed to ensure DLTs are safe, secure, and trustworthy.,Interdisciplinary teams with members from academia, business and industry, and from disciplines such as business, entrepreneurship, theoretical and practical computer science, cybersecurity, finance, mathematics and statistics, must be formed. Such teams must collaborate with the objective of developing strategies and techniques for ensuring the correctness and security of future DLSs in which our society may become dependent.,The value and originality of this article is twofold: the disproving, through fact collection and systematic analysis, of current misconceptions about the properties of the blockchain and DLSs, and the discussion of challenges to achieving adequate trustworthiness along with the proposal of general avenues for possible solutions.

Agile deployment and code coverage testing metrics of the boot software on-board Solar Orbiter's Energetic Particle Detector

In this day and age, successful embedded critical software needs agile and continuous development and testing procedures. This paper presents the overall testing and code coverage metrics obtained during the unit testing procedure carried out to verify the correctness of the boot software that will run in the Instrument Control Unit (ICU) of the Energetic Particle Detector (EPD) on-board Solar Orbiter. The ICU boot software is a critical part of the project so its verification should be addressed at an early development stage, so any test case missed in this process may affect the quality of the overall on-board software. According to the European Cooperation for Space Standardization ESA standards, testing this kind of critical software must cover 100% of the source code statement and decision paths. This leads to the complete testing of fault tolerance and recovery mechanisms that have to resolve every possible memory corruption or communication error brought about by the space environment. The introduced procedure enables fault injection from the beginning of the development process and enables to fulfill the exigent code coverage demands on the boot software.

Righting Technologies: How Large-Scale Assessment Can Foster a More Equitable Education System

Author(s): Behizadeh, Nadia; Lynch, Tom Liam | Abstract: For the last century, the quality of large-scale assessment in the United States has been undermined by narrow educational theory and hindered by limitations in technology. As a result, poor assessment practices have encouraged low-level instructional practices that disparately affect students from the most disadvantaged communities and schools. In this historical and theoretical review, we examine the misalignment between educational theory and large-scale assessment practices that rely upon technology, using writing assessment as a case in point. Drawing upon sociocultural theory and critical software studies as conceptual frameworks, we find that today’s software-powered technologies, although capable of taking progressive educational ideals to scale, have not been used for these purposes. Our proposed solution is to shift from using technologies to assess predetermined samples of evidence of learning to using technologies to facilitate complex and negotiated models of assessment. This solution would require policy shifts that honor the needs of various stakeholders in the assessment process. We offer a power-sharing concept called negotiated control that engages policymakers, educators, researchers, and community members inthe assessment process.

AN APPROACH FOR AUTOMATING DESIGN OF WEB, ITS METRICS & KNOWLEDGE-BASE

In view of the fact that web applications are significantly large, complex, highly dynamic & critical software systems, it is desirable that processes of web design and development be systematic & be automated as far as possible. The task of automating an engineering activity is quite complex because it involves two types of contrasting intelligences: (i) Human intelligence which is rooted in informal expression, judgmental evaluation, inductive reasoning and commonsense, and (ii) The machine intelligence which is essentially based on formal expression, formal rule-based evaluation & deductive reasoning etc. Human intelligence is required for understanding the problem domains & their environments, and then for using the understanding for designing & developing solutions in such a form that it is understood and executed by the contrasting intelligence, viz. the machine intelligence. The proposed approach takes care of the facts of human capabilities being rooted in informality & of machine capabilities being purely formal. For this purpose, solutions conceived by human experts—which are generally expressed in some natural language—are, first of all, translated to semi-formal mathematical entities: recursive lists. These recursive lists then are easily translated to fully formal entities in some functional programming language like LISP or Haskell. In this communication, the approach is applied to structural aspects of web and is explained through sufficient exemplars. The dynamics of web will be discussed subsequently.

A formally verified compiler for Lustre

The correct compilation of block diagram languages like Lustre, Scade, and a discrete subset of Simulink is important since they are used to program critical embedded control software. We describe the specification and verification in an Interactive Theorem Prover of a compilation chain that treats the key aspects of Lustre: sampling, nodes, and delays. Building on CompCert, we show that repeated execution of the generated assembly code faithfully implements the dataflow semantics of source programs. We resolve two key technical challenges. The first is the change from a synchronous dataflow semantics, where programs manipulate streams of values, to an imperative one, where computations manipulate memory sequentially. The second is the verified compilation of an imperative language with encapsulated state to C code where the state is realized by nested records. We also treat a standard control optimization that eliminates unnecessary conditional statements.

Safety Critical Software Development: A Modeling Approach

Safety Critical Software Development: A Modeling Approach

Evaluation of reliability of critical software system using fuzzy approach

The demand for reliable critical software system is increasing in exponential way. In critical software system reliability is considered as an important quality factor. Reliability itself depends on various factors. To develop reliable critical software system it is very important to evaluate reliability in active and efficient manner. Soft Computing techniques are effective in assessment of models. The main objective of this study is to develop a reliability model that is based on important factors. The secondary objective is to evaluate the model by using fuzzy logic/soft computing. Since multiple factors have impact on reliability so fuzzy logic will help to provide specific solution for imprecise and ambiguous concepts by converting vague information into a good judgmental model Critical software system selection is a complex task. Four factors are considered to evaluate the reliability. Then the evaluation results are validated by using defuzzification. The proposed model can be implemented for various applications in an effective manner.

A Survey on Test Case Prioritization Techniques for Regression Testing

Objective: The main intent of this research is to provide prioritization of test cases in regression testing for various applications. For that, several test case prioritization techniques which are classified based on various parameters are investigated. Methods/Statistical Analysis: In this manuscript, a survey has been made on various test case prioritization techniques for regression testing. Several test case prioritization techniques are presented for regression testing of various applications. One of the suggested technique is Reinforcement Learning (RL) based Hidden Markov Model (HMM) method for prioritizing test cases during regression testing of Graphical User Interface (GUI) applications. Results: This survey comprehensively studies the issues in test case prioritization techniques for regression testing. The performance of different methods is compared with various parameters such as Average Percentage Faults Detected (APFD), effect size, statistical testing. The mean values of APFD for RL-Based HMM model method is 0.68, for accumulated Q-value method is 0.62 and for statement coverage method is 0.61. Findings: The major findings in this survey are that test case prioritization is still at its primitive stages and more research is required to make it applicable in today’s world. It can be applied to all streams of computer engineering if made practically feasible. Currently test case prioritization is only applied where there is no consideration of cost like safety critical software. Many existing methods are surveyed in this work and the findings suggest that model based test case prioritization is best in all aspects. Application/Improvement: Test case prioritization can be applied to all kinds of software once it is cost effective and practically feasible but currently its application is limited to some software components only. Conclusion: This survey investigates several test case prioritization techniques and provides the idea for efficient methods for future work.

Establishing A-Priori Performance Guarantees for Robot Missions that Include Localization Software

One approach to determining whether an automated system is performing correctly is to monitor its performance, signaling when the performance is not acceptable; another approach is to automatically analyze the possible behaviors of the system a-priori and determine performance guarantees. Thea authors have applied this second approach to automatically derive performance guarantees for behavior-based, multi-robot critical mission software using an innovative approach to formal verification for robotic software. Localization and mapping algorithms can allow a robot to navigate well in an unknown environment. However, whether such algorithms enhance any specific robot mission is currently a matter for empirical validation. Several approaches to incorporating pre-existing software into the authors' probabilistic verification framework are presented, and one used to include Monte-Carlo based localization software. Verification and experimental validation results are discussed for real localization missions with this software, showing that the proposed approach accurately predicts performance.

Extracting and Conserving Production Data as Test Cases in Executable Business Process Architectures

Because executable business processes are an important and critical software asset of organizations because they control and integrate critical information systems. Thus, testing them thoroughly is a very important task within the software development process. However, failures due to implementation defects still occur in production, which in turn means that the development team needs to analyze, fix and repair the failing processes. In order to support the activities of reproducing the problem outside of the production system and to create better test cases for verifying the fixed implementation, we propose to use process mining techniques on the production process event logs to aid the support & development teams. With our approach it is possible to automatically extract a working unit test case with all partner services being mocked that can run in a development environment. Within in this paper we present the extraction algorithm, our implementation, and possible ways to integrate the tool into the support & development process.

Righting Technologies: How Large-Scale Assessment Can Foster a More Equitable Education System

For the last century, the quality of large-scale assessment in the United States has been undermined by narrow educational theory and hindered by limitations in technology. As a result, poor assessment practices have encouraged low-level instructional practices that disparately affect students from the most disadvantaged communities and schools. In this historical and theoretical review, we examine the misalignment between educational theory and large-scale assessment practices that rely upon technology, using writing assessment as a case in point. Drawing upon sociocultural theory and critical software studies as conceptual frameworks, we find that today’s software-powered technologies, although capable of taking progressive educational ideals to scale, have not been used for these purposes. Our proposed solution is to shift from using technologies to assess predetermined samples of evidence of learning to using technologies to facilitate complex and negotiated models of assessment. This solution would require policy shifts that honor the needs of various stakeholders in the assessment process. We offer a power-sharing concept called negotiated control that engages policymakers, educators, researchers, and community members inthe assessment process.

LMS-Verify: abstraction without regret for verified systems programming

Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. High-level languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.Recent years have seen a surge in staging and generative programming: the key idea is to use high-level languages and their abstraction power as glorified macro systems to compose code fragments in first-order, potentially domain-specific, intermediate languages, from which fast C can be emitted. But what about security? Since the end result is still C code, the safety guarantees of the high-level host language are lost.In this paper, we extend this generative approach to emit ACSL specifications along with C code. We demonstrate that staging achieves ``abstraction without regret'' for verification: we show how high-level programming models, in particular higher-order composable contracts from dynamic languages, can be used at generation time to compose and generate first-order specifications that can be statically checked by existing tools. We also show how type classes can automatically attach invariants to data types, reducing the need for repetitive manual annotations.We evaluate our system on several case studies that varyingly exercise verification of memory safety, overflow safety, and functional correctness. We feature an HTTP parser that is (1) fast (2) high-level: implemented using staged parser combinators (3) secure: with verified memory safety. This result is significant, as input parsing is a key attack vector, and vulnerabilities related to HTTP parsing have been documented in all widely-used web servers.

Characterizing Direct Monitoring Techniques in Software Systems

Monitoring is a consolidated practice to characterize the dependability behavior of a software system. A variety of techniques, such as event logging and operating system probes, are currently used to generate monitoring data for troubleshooting and failure analysis. In spite of the importance of monitoring, whose role can be essential in critical software systems, there is a lack of studies addressing the assessment and the comparison of the techniques aiming to monitor the occurrence of failures during operations. This paper proposes a method to characterize the monitoring techniques implemented in a software system. The method is based on a fault injection approach and allows measuring 1) precision and recall of a monitoring technique and 2) the dissimilarity of the data it generates upon failures. The method has been used in two critical software systems implementing event logging, assertion checking, and source code instrumentation techniques. We analyzed a total of 3 844 failures. With respect to our data, we observed that the effectiveness of a technique is strongly affected by the system and type of failure, and that the combination of different techniques is potentially beneficial to increase the overall failure reporting ability. More important, our analysis revealed a number of practical implications to be taken into account when developing a monitoring technique.

Approach to the development of a Unified Framework for Safety Critical Software Development

Software is increasingly being used to provide functionality in safety critical domains. The complexity involved in the development of software for these domains can bring challenges concerned with safety. International standards are published, providing information on practices which must be implemented in order to satisfy the regulations. This paper details an investigation of the relevant standards that companies need to implement in order to satisfy the regulatory requirements. A literature review was conducted which examines the relevant Quality Management System, Risk Management and Software Development standards across the safety critical domains; and examines the challenges faced by software development organizations with standard and multiple standard implementation. The existing approaches to standards consolidation, integration and harmonization were also examined. To investigate the challenges in implementing these standards, interviews were conducted with a medical device software development company having a Quality Management System in place and beginning to implement the relevant Software Development standards. In addition, an interview was conducted with a consultancy company who has experience in the implementation and maintenance of Quality Management Systems in small and medium enterprises. Following the literature review and interviews conducted, a comparison of the standards was conducted to investigate the similarities and differences in the structure of sections and subsections and to estimate the potential for the further consolidation of these standards. Following the results of the comparisons, a detailed mapping of standard requirements was conducted, mapping requirements of generic and domain specific Quality Management System standards. Future work will focus on the consolidation and integration of standards practices which need to be implemented by companies developing safety critical software and development of Unified Framework that incorporates all necessary requirements to comply with regulatory requirements.

Simulation of wind-generated surface waves and effects of bubbles on scattering, transmission, and attenuation of low frequency sound at the sea surface

Sea surface virtual acoustic simulator lab (SSVASL) is a software based on a newly presented reformed Helmholtz-Kirchhoff-Fresnel method developed in FORTRAN programming language. Based on the resonance dispersion model (RDM), bubbles deformation at frequency range below 200 Hz can cause different physical features such as dynamic density and resonance dependence of phase velocity in bubbly water medium. Therefore, the initial Helmholtz-Kirchhoff-Fresnel (HKF) method which only considers the surface roughness effects is optimized as reformed HKF to entail the influence of subsurface bubble population on the arrival of sound to the sea surface. Considering an acoustical system in which scattering, transmission, and attenuation phenomena occur, effects of sea surface on the emitted sound are simulated by SSVASL. The SSVASL code, by considering the RDM model and void fraction of bubbly medium in frequency range below 1000 Hz and wind-generated surface waves, is capable of providing surface scattering strengths, transmission change, and damping coefficients of rough bubbly air–water interface for a localized point source. For verification purposes, experimental results of critical sea tests, FLIPEX software, and prominent Tolstoy’s approach are considered in sound scattering, transmission, and attenuation phenomena at the sea surface, respectively. The obtained procedure and results can be very helpful in many acoustics-related studies in the ocean environment including acoustic Doppler current profiler, sonar performance, marine life, and oceanography among others.

Investigating relationships between functional coupling and the energy efficiency of embedded software

Software coupling involves dependencies among pieces of software called modules. Different types of coupling will dictate the manner whereby software modules interact and will result in different approaches to mutual function calls and return values, which can affect software quality attributes. Undoubtedly, coupling has been one of the most critical factors for supporting software modularity because it affects such important software quality attributes as reusability, readability, and maintainability. It is no surprise that coupling can affect energy efficiency. Recently, energy efficiency has increasingly been recognized as a critical software quality attribute, particularly for embedded software, including smartphone applications. Unfortunately, few studies have been conducted to date concerning coupling in developing energy-efficient and modular software, other than general studies on energy consumption and resource overutilization in the context of modularity. In this study, we aim to investigate the relationship between energy consumption and software coupling. In particular, we aim to determine whether it is possible to control energy consumption by applying different types of software coupling and, if so, how this might be done. We have performed a large number of experiments from which we have gained insight, although that insight might not be applicable to all possible types of coupling that are feasible, to help guide software engineers in developing energy-efficient embedded software. From the experimental results, we observe that overall “data” coupling reduces energy consumption when a large amount of data must be passed from one module to another, whereas “common” coupling is preferred when continuous memory references are needed, although energy consumption can also be somewhat dependent upon the operating environment. We describe such insights into the relationship between energy consumption and software coupling.

Building Critical Applications Using Microservices

Microservices - combined with secure containers - facilitate new ways to build critical applications. These applications will benefit from many tools and services built for less critical software. The more stringent requirements of critical applications are addressed with the help of secure containers and compiler extensions. While this approach is sufficient for implementing fail-stop applications, there are still several open research questions regarding if and how fail-operational applications could be supported using this approach.

A Bayesian Networks-Based Risk Identification Approach for Software Process Risk: The Context of Chinese Trustworthy Software

For all of the many advantages and enormous benefits that information technology has brought to us, it has subjected to increasing risks that need enough attention. Bayesian network (BN) is an important probabilistic inference approach to support reasoning under uncertainty. This paper describes how BN is applied to quantify the occurrence probability of software process risk factors and the influence strength among the process risk factors in the context of Chinese trustworthy software. The information of 52 factors was obtained through a questionnaire survey of 93 project managers in five high Capability Maturity Model Integration (CMMI) level software companies. The focus of this paper is to present the key risk checklist and good timing for process risk control to improve software process risk management. Special effort has been put on the description of the experimental study, which provides the top 20 key risk factors in software process and critical software sub-processes for process risk management. The findings can provide the key risk checklist to software risk manager for risk identification and decision-making in process risk management. This is a general approach and, as such, it can be applied to a certain software project or some software enterprises with updated data.