Oscar Mondragon

SUPPORTING ELICITATION AND SPECIFICATION OF SOFTWARE PROPERTIES THROUGH PATTERNS AND COMPOSITE PROPOSITIONS

Prospec is a tool that assists practitioners in the elicitation and specification of system properties. Practitioners are guided by questions, definitions, and graphics. Prospec introduces the use of composite propositions to identify intended behavior when multiple conditions or events are considered. Multiple conditions or events may represent behavior such as sequences, concurrency, and non-determinism and may define the boundaries of scopes or type of patterns. Prospec is built upon the Specification Pattern System. The tool assists the analyst in making informed decisions about aspects of a specification that may have multiple interpretations. The end product of the tool is a formal specification in Future Interval Logic, Linear Temporal Logic, or Meta Event Definition Language.

Prospec: Support for elicitation and formal specification of software properties

Abstract Although formal verification techniques have been demonstrated to improve program dependability, software practitioners have not widely adopted them. One reason often cited is the difficulty in writing formal specifications. This paper introduces Prospec, a tool to assist practitioners in formally specifying software properties. Prospec uses property patterns and scopes. Previous efforts at providing tool support for property specification have not provided convenient abstractions for specifying properties that include multiple events or conditions. A taxonomy of composite propositions is introduced to address this issue by defining relations among propositions and providing graphical abstractions that can assist in specification and validation of properties. This paper shows how composite propositions can enhance the specification pattern system by helping practitioners consider subtleties of behavior in sequences and concurrency through directed questions and visual abstractions. The paper introduces an elicitation and specification process to define patterns, scopes, and composite propositions.

DynaMICs: Comprehensive support for run-time monitoring

Abstract Software engineering strives to enable the economic construction of software systems that behave reliably, predictably, and safely. In other engineering disciplines, safety is assured in part by detailed monitoring of processes. In software, we may achieve some level of confidence in the operation of programs by monitoring their execution. DynaMICs is a software tool that facilitates the collection and use of constraints for software systems. In addition, it supports traceability by mapping constraints to system artifacts. Constraint specifications are stored separately from code; constraint-monitoring code is automatically generated from the specifications and inserted into the program at appropriate places; and constraints are verified at execution time. These constraint checks are triggered by changes made to variable values. We describe the architecture of DynaMICs, discuss alternative verification techniques, and outline research directions for the DynaMICs project.

A structured approach for managing a practical software engineering course

The challenges of teaching software engineering include achieving functioning teams, enforcing individual accountability, ensuring progress of the students, and evaluating quality of the product. The two-semester, software engineering course at the University of Texas at El Paso incorporates a cooperative group method and an improvement process model that enables learning from past results. The course centers on a cross-disciplinary, large-scale project that provides students with an opportunity to deal with the challenges of developing a real-world product. The experience of working with incomplete, ambiguous and changing requirements motivates the need for applying software engineering techniques and approaches to the project. In the first semester, students perform analysis and define requirements specifications for the proposed system. The second semester course covers design, implementation, and testing. This paper details the structure of the course. Specifically, it outlines how cooperative teams are structured, how students learn the importance of process refinement and improvement, and how the project is presented and managed while achieving individual accountability.

Verifying pattern-generated LTL formulas: a case study

The Specification Pattern System (SPS) and the Property Specification (Prospec) tool assist a user in generating formal specifications in Linear Temporal Logic (LTL), as well as other languages, from property patterns and scopes. Patterns are high-level abstractions that provide descriptions of common properties, and scopes describe the extent of program execution over which the property holds. The purpose of the work presented in this paper is to verify that the generated LTL formulas match the natural language descriptions, timelines, and traces of computation that describe the pattern and scope. The LTL formulas were verified using the Spin model checker on test cases developed using boundary value analysis and equivalence class testing strategies. A test case is an LTL formula and a sequence of Boolean valuations. The LTL formulas were those generated from SPS and Prospec. The Boolean valuations of propositions in the LTL formula are generated by a deterministic, single-threaded Promela program that was run using the software model-checker Spin. For each pattern, a suite of test cases was. The experiments uncovered several errors in both the SPS-generated and the Prospec-generated formulas.

FasTLInC: a constraint-based tracing approach

In an approach to software monitoring called Dynamic Monitoring with Integrity Constraints (DynaMICs), integrity constraints are used to monitor program behavior at runtime. The constraints capture domain knowledge, limitations imposed by the design, and assumptions made by programmers. This paper introduces Fast Tracing with Links using Integrity Constraints (FasTLInC), a component of DynaMICs, that manages integrity-constraint specifications, software artifacts, and program state information, permitting tracing of constraints and artifacts, specifically requirements and source code. Because DynaMICs verifies that a program behaves in accordance to constraints, the traceability provided by FasTLInC is significant since the monitor targets the detection of faults that result from ambiguity and changes in requirements, conflicts among requirements, and change in program use. The automated identification of bi-directional links between constraints and code eliminates the laborious task of managing links, which can be problematic because of the evolutionary nature of code.

Composite propositions: toward support for formal specification of system properties

Formal specification and analysis of software properties can be useful in reducing the number of errors in production software. More intuitive methods of specifying constraints and system properties are needed so that developers and other stakeholders can participate in validation of formal software requirements. This work introduces composite propositions, a set of abstractions that define the relations between sets of conditions or events, and it is directed at making the specification of common temporal properties accessible to practitioners and clients. Composite propositions can be used with response formulas to describe concurrent behavior such as concurrency, synchronization, and nondeterminism. Composite propositions assist in the elicitation and validation of properties facilitating the integration of formal approaches into the software development lifecycle.

Instrumentation of intermediate code for runtime verification

Runtime monitoring is aimed at ensuring correct runtime behavior with respect to specified constraints. It provides assurance that properties are maintained during a given program execution. The dynamic monitoring with integrity constraints (DynaMICs) approach is a runtime monitoring system under development at the University of Texas at El Paso. The focus of the paper is on the identification of instructions at the object-code level that require instrumentation for monitoring. Automated instrumentation is desirable because it can reduce errors introduced by humans, it provides finer control over monitoring, and it allows greater control over instrumentation. The paper also discusses two other technologies associated with DynaMICs: the elicitation and formal specification of properties and constraint; and tracing property or constraint violations to the software engineering artifacts from which the constraints and properties were derived.

A collaborative, interdisciplinary initiative for a smart cities innovation network

A smart city is characterized by its ability to integrate people, technology and information to create a sustainable and resilient infrastructure that provides high quality services for residents. Transforming a city into a smart city requires collaborative efforts between government, industry, practitioners, residents and researchers. This paper describes how researchers in a recently formed consortium of three universities are developing a smart cities innovation network, with an emphasis on smart mobility, smart buildings, and smart bridges. The consortium is applying a semantic-based approach to address the initial challenge of building an effective interdisciplinary network of university researchers located in different parts of the world, in three cities with different sizes and stages of economic development.

CAD tools for developing modularly configured attached processors

A computer-aided design tool, the SIMARC package, is used for the fast prototyping of modularly configured attached processor (MCAP) architectures. This tool consists of a graphics-user-interface (GUI) architecture editor, a GUI assembler tool, and a GUI simulator tool. This document presents the standard set of connections and component types that form the structure of a MCAP architecture. A new architecture for the conjugate gradient algorithm is introduced.