Program complexity using Hierarchical Abstract Computers

This paper studies how streamflow predictability varies with basin characteristics. We introduce an index of basin complexity that is based on a model of least statistical complexity that is needed to reliably predict daily streamflow of the basin. We then relate it with climate, vegetation and soil characteristics of the basin. Daily streamflow is modeled using k nearest neighbor model of lagged streamflow that predicts next time step streamflow based on the occurrences of similar streamflow events from the past. In order to calculate basin complexity, we identify difficult streamflow events of the basin and then use Vapnik‐Chervonenkis generalization theory, which trades off model performance with Vapnik‐Chervonenkis dimension (i.e., a measure of model complexity), to find a k nearest neighbor model of appropriate complexity for predicting a difficult streamflow event of the basin. The average of selected model complexities corresponding to difficult events is then defined as the basin's complexity. Basin complexity of 412 Model Parameter Estimation Experiment basins from continental United States are then related with its six basin characteristics. All the characteristics have been derived from the Model Parameter Estimation Experiment database to represent climate, vegetation and soil characteristics of the basins in a concise manner. Results find that more complex basins that are drier have less seasonal rainfall, vegetation with more storage capacity (i.e., smaller 5‐week Normalized Difference Vegetation Index gradient), and faster responsive soils. The results reaffirm prior observations that minimum complexity that is required to model a basin depends on its climate and landscape characteristics (e.g., complex models do not perform well in dry basins).

Technological developments occurring at the beginning of this century and particularly from the 1950s onward led to the construction of large, complex systems which were both productive and dangerous. The word dangerous can have many meanings: unsafe (nuclear power plants), or sensitive but essential (computer systems of a company), etc. Observations have shown that minor causes can lead to major effects resulting in undesirable events. Studies have been undertaken over the last forty years to predict and avoid these events. These studies constitute an interdisciplinary concept known as reliability . The 1970s constitute the turning period for the hardware/software dichotomy in industrial systems, and the importance of software is increasing rapidly. The main feature of software, as compared to hardware, is that it is not subject to physical breakdown due to wear and tear. The idea followed by researchers and practitioners since then is to concentrate effort in the requirement, specification, design, coding, and testing phases of development in order to ensure high quality and zero defect software at delivery time. These efforts have resulted in the accumulation of an enormous set of development methodologies and techniques accompanied by appropriated languages and tools. These languages and tools are used to improve the adherence to software production requirements, e.g., costs, schedule, and technical characteristics such as performance and reliability. Quantitative methods used in the latter steps of development such as reliability estimation or testing techniques help to increase confidence in the software. During the design phase, qualitative methods can be used efficiently for certain types of studies (safety, availability, etc.) for it is widely accepted that fixing a bug in early phases of development minimizes cost and efforts. Failure modes and effects analysis (FMEA) is one of these methods: originally developed for use in a hardware context, the technique was applied during the 1970s to software development. First its utilization by the hardware community is recieved. After a survey of FMEA's application in software, its role in the software process and its place in the software life‐cycle development are described. Procedures for its implementation will constitute the last part of the article.

In this chapter, we explore several issues of complexity in molecular design, focusing initially on the complexity model that we introduced over 10 years ago, which explores the probability of useful interactions occurring with ligands and binding sites of differing complexity. We explore some extensions of the model, which include uniqueness of binding mode and sensitivity of detection. In addition, we review the promiscuity data that supports and challenges the model, concluding that the use of molecular weight as a complexity measure does not account for the promiscuity introduced by excessive lipophilicity. We explore the subject of molecular interactions from the perspective of Shannon entropy and how this may help to understand some of the issues associated with lipophilic interactions. We then address the issues associated with sampling of chemical space and the challenges of understanding and navigating the vastness of such spaces. The challenge of understanding the complexity of thermodynamic entropy and enthalpy is also discussed. Finally, we discuss the challenges of taking a reductionist approach to drug discovery and how the emergence of new behaviors as complexity is rebuilt is difficult to predict and hence prepare for in advance.

Quantitative evaluation of safety-critical software at the early development stage: an interposing logic system software example

1 - Reliability overview

We develop a method for matching dynamic histories of program executions of two program versions. The matches produced can be useful in many applications including software piracy detection and several debugging scenarios. Unlike some static approaches for matching program versions, our approach does not require access to source code of the two program versions because dynamic histories can be collected by running instrumented versions of program binaries. We base our matching algorithm on comparison of rich program execution histories which include: control flow taken, values produced, addresses referenced, as well as data dependences exercised. In developing a matching algorithm we had two goals: producing an accurate match and producing it quickly. By using rich execution history, we are able to compare the program versions across many behavioral dimensions. The result is a fast and highly precise matching algorithm. Our algorithm first uses individual histories of instructions to identify multiple potential matches and then it refines the set of matches by matching the data dependence structure established by the matching instructions. To test our algorithm we attempted matching of execution histories of unoptimized and optimized program versions. Our results show that our algorithm produces highly accurate matches which are highly effective when used in comparison checking approach to debugging optimized code.

In this paper we are concerned with questions about the knottedness of a closed curve of given length embedded in Z3. What is the probability that such a randomly chosen embedding is knotted? What is the probability that the embedding contains a particular knot? What is the expected complexity of the knot? To what extent can these questions also be answered for a graph of a given homeomorphism type?We use a pattern theorem due to Kesten 12 to prove that almost all embeddings in Z3 of a sufficiently long closed curve contain any given knot. We introduce the idea of a good measure of knot complexity. This is a function F which maps the set of equivalence classes of embeddings into 0, ). The F measure of the unknot is zero, and, generally speaking, the more complex the prime knot decomposition of a given knot type, the greater its F measure. We prove that the average value of F diverges to infinity as the length (n) of the embedding goes to infinity, at least linearly in n. One example of a good measure of knot complexity is crossing number.Finally we consider similar questions for embeddings of graphs. We show that for a fixed homeomorphism type, as the number of edges n goes to infinity, almost all embeddings are knotted if the homeomorphism type does not contain a cut edge. We prove a weaker result in the case that the homeomorphism type contains at least one cut edge and at least one cycle.

As nuclear power plants undertake main control room modernization, a challenge is the lack of a clearly defined human factors process to follow. Verification and validation (V&V) as applied in the nuclear power community has tended to involve efforts such as integrated system validation, which comes at the tail end of the design stage. To fill in guidance gaps and create a step-by-step process for control room modernization, we have developed the Guideline for Operational Nuclear Usability and Knowledge Elicitation (GONUKE). This approach builds on best practices in the software industry, which prescribe an iterative user-centered approach featuring multiple cycles of design and evaluation. Nuclear regulatory guidance for control room design emphasizes summative evaluation—which occurs after the design is complete. In the GONUKE approach, evaluation is also performed at the formative stage of design—early in the design cycle using mockups and prototypes for evaluation. The evaluation may involve expert review (e.g., software heuristic evaluation at the formative stage and design verification against human factors standards like NUREG-0700 at the summative stage). The evaluation may also involve user testing (e.g., usability testing at the formative stage and integrated system validation at the summative stage). An additional, often overlooked component of evaluation is knowledge elicitation, which captures operator insights into the system. In this report we outline these evaluation types across design phases that support the overall modernization process. The objective is to provide industry-suitable guidance for steps to be taken in support of the design and evaluation of a new human-machine interface (HMI) in the control room. We suggest the value of early-stage V&V and highlight how this early-stage V&V can help improve the design process for control room modernization. We argue that there is a need to overcome two shortcomings of V&V in current practice—the propensity for late-stage V&V and the use of increasingly complex psychological assessment measures for V&V.

The European Union General Data Protection Regulation (GDPR) governs personal data processing, aiming to ensure privacy in all systems handling such data. All systems that process personal data, including software systems are legally obliged to comply to all articles of the GDPR applicable to them. In this paper, the case study of an e-Learning software platform, namely the INFORM platform and its compliance to relevant articles of the GDPR is presented. The e-Learning platform was developed with the objective to host the educational material developed under the JUSTICE EU-funded project INFORM, targeting judiciary, court staff and legal practitioners, in order to provide free and open distance access to the content. In particular, the paper demonstrates the compliance of the platform with the articles and principles of: Data Minimisation, Lawfulness of Processing, Right to Erasure, Right of Access, Right to Data Portability, Right to Rectification and Security of Processing. By applying these articles, conformance to the provision for Data Protection by design is also achieved; the platform's software development process integrates the articles of the GDPR early in the development steps, from the specification and design phases. We show how the design process progressed and demonstrate the corresponding functionality within the e-Learning platform. The paper extracts a list of lessons learned and conclusions on software GDPR compliance.

Assessment model for perceived visual complexity of painting images

Chunks: A basis for complexity measurement

For common data flow schemes, the number of copies of tokens made during a computation is shown to be a Blum complexity measure.(1) Results from abstract complexity theory (see Ref. 2) then hold for the copy measure, indicating, for example, that any implementation of a data flow processor will be constrained by its ability to copy tokens. The copy measure is a natural measure of complexity for data flow computations, and is distinct from the usual time or space measures. The result is generalized to a wider class of data flow schemas, including those with an apply operator. An example is also given of a data flow scheme which makes no copies.

This paper introduces graphical user interface (GUI) modelling approach and it positions in information system (IS) development process. The overview of graphical user interface design methods and methodologies is presented. The main objective of the proposal is the consistency of IS development process, which includes requirements specification, system design and implementation phases. The GUI modelling process is based on the data flows specification. Detailed explanation of modelling steps is presented. Paper includes an illustrative example of the web based GUI development according to the proposed process.

Engineering safe, complex real-time systems is challenging. Engineering mobile systems of systems that are safe and possibly autonomous, requires considerable support from competent specification based architecture, model-based design processes and concomitant large-scale, heterogeneous simulation capabilities. Safety - the dominatrix of autonomy - is determined by requirements that then propagate through the specification, architecture, design, verification, validation and calibration phases of the real-time engineering process. In real-time systems, time is a 1st class, functional property of the system. The paper describes a specification-based architecture for the engineering of safe mobile system of systems and the modeling and simulation technology required to produce them.

ATHENA is a parametrizable software tool oriented towards the measurement of software quality characteristics. Measurement is based on the syntax and semantic (graph‐based) analysis of programs. ATHENA is language‐independent and customizable, i.e. language specifications as well as measurement algorithms are input to the tool which automatically generates the measurement environment for the corresponding language. Currently ATHENA has the ability to support Pascal, ADA and C and offers the possibility of measuring a set of kernel metrics (e.g. Halstead's ‘Software Complexity Measure’, McCabe's ‘Cyclomatic Complexity Metric’, Tai's ‘Data Flow Complexity Measure’ etc.). A specially designed specification language allows for easy implementation of design and code metrics. This is one of the reasons that ATHENA is particularly useful for software maintainability control.