Application of a Methodology for the Development and Validation of Reliable Process Control Software

This paper discusses the necessity of a good methodology for the development of reliable software, especialy with respect to the final software validation and testing activities. A formal specification development and validation methodology is proposed. This methodology has been applied to the development and validation of a pilot software, incorporating typical features of critical software for nuclear power plant safety protection. The main features of the approach indude the use of a formal specification language and the independent development of two sets of specifications. Analyses on the specifications consists of three-parts: validation against the functional requirements consistency and integrity of the specifications, and dual specification comparison based on a high-level symbolic execution technique. Dual design, implementation, and testing are performed. Automated tools to facilitate the validation and testing activities are developed to support the methodology. These includes the symbolic executor and test data generator/dual program monitor system. The experiences of applying the methodology to the pilot software are discussed, and the impact on the quality of the software is assessed.     

CORAMOD: a checklist-oriented model-based requirements analysis approach

Requirement development activities such as requirements analysis and modelling are well defined in software engineering. A model-based requirement development may result in significant improvements in engineering design. In current product development activities in this domain, not all requirements are consciously identified and modelled. This paper presents the checklist-oriented requirements analysis modelling (CORAMOD) approach. CORAMOD is a methodology for the use of model-based systems engineering for requirements analysis of complex products utilizing checklists, the simplest kind of rational design method. The model-based focuses the requirements analysis process on requirement modelling, whereas the checklist encourages a conscious and systematic approach to identify requirements. We illustrate the utility of CORAMOD artefacts by a comprehensive case study example and modelling with system modelling language (SysML). We suggest that visual accessibility of the SysML views facilitates the full participation of all stakeholders and enables the necessary dialogue and negotiation. The approach promotes tracing derived requirements to the customer need statement and enhances validation by model execution and simulation.     

Software systems development in petroleum engineering

Many approaches to designing software systems have been developed for use in commercial or business environments. These development methods and procedures have improved dramatically over the last ten years although it is only recently that these have been employed in scientific and technological applications. Many of these implementations have been unsuccessful because the design methodology has been divorced from the practical requirements of the industry in which the software system is to operate. This paper discusses a modern approach to software development which directly relates to an engineering environment and which is designed to satisfy practical criteria of acceptability of the software when delivered to the petroleum engineer. Since all field developments nowadays rely heavily on associated software systems, the approach presented here can lead to improved mechanical systems reliability and shorter development/design cycles.     

An intelligent assistant for requirements validation

The process of determining user requirements for software systems is often plagued with uncertainty, ambiguity, and inconsistency. Rapid prototyping offers an iterative approach to requirements engineering that can be used to alleviate some of the problems with communication and understanding. Since the systems development process is characterized by changing requirements and assumptions, involving multiple stakeholders with often differing viewpoints, it is beneficial to capture the justifications for the decisions in the development process in a structured manner. Thisdesign rationale captured during requirements engineering can be used in conjunction with the rapid prototyping process to support various stakeholders involved in systems development. CAPS (the Computer Aided Prototyping System) has been built to help software engineers rapidly construct prototypes of proposed software systems. REMAP (Representation and MAintenance of Process knowledge) provides a conceptual model and mechanisms to represent and reason with (design) rationale knowledge. In this paper, we describe how in the context of evolving requirements, the CAPS system augmented with REMAP helps firm up software requirements through iterative negotiations via examination of executable prototypes and reasoning with design rationale knowledge.     

A prototyping language for real-time software

PSDL is a language for describing prototypes of real-time software systems. It is most useful for requirements analysis, feasibility studies, and the design of large embedded systems. PSDL has facilities for recording and enforcing timing constraints, and for modeling the control aspects of real-time systems using nonprocedural control constraints, operator abstractions, and data abstractions. The language has been designed for use with an associated prototyping methodology. PSDL prototypes are executable if supported by a software base containing reusable software components in an underlying programming language (e.g. Ada)     

A UML-based static verification framework for security

Secure software engineering is a new research area that has been proposed to address security issues during the development of software systems. This new area of research advocates that security characteristics should be considered from the early stages of the software development life cycle and should not be added as another layer in the system on an ad-hoc basis after the system is built. In this paper, we describe a UML-based Static Verification Framework (USVF) to support the design and verification of secure software systems in early stages of the software development life-cycle taking into consideration security and general requirements of the software system. USVF performs static verification on UML models consisting of UML class and state machine diagrams extended by an action language. We present an operational semantics of UML models, define a property specification language designed to reason about temporal and general properties of UML state machines using the semantic domains of the former, and implement the model checking process by translating models and properties into Promela, the input language of the SPIN model checker. We show that the methodology can be applied to the verification of security properties by representing the main aspects of security, namely availability, integrity and confidentiality, in the USVF property specification language.     

Agent-based framework for integrated facility engineering

An agent-based framework for the development of integrated facility engineering environments in support of collaborative design is introduced. This framework aims at integrating design software by allowing better software interoperability. Within their framework, design agents represent various existing design and planning systems that communicate their design information and knowledge partially and incrementally using the Agent Communication Language (ACL). ACL is a formal language proposed as a communication standard for disparate software. It is based on a logic-based language called Knowledge Interchange Format (KIF) and a message protocol called Knowledge Query Manipulation Language (KQML). Design agents are linked and their communication of design information is coordinated via system programs called facilitators in a federation architecture. The federation architecture specifies the way design agents and facilitators communicate in an integrated software environment. In concert with pursuing fundamental research concepts, we have been developing an integrated design software environment that spans different phases of the facility life cycle. This environment serves to demonstrate the primary aspects of this research methodology. In this paper, we first discuss the integration problem and review related research projects. We then present the major aspects of agent-based software engineering methodology and its application to integrated facility engineering. A highlight of the current integrated design environment development is given to illustrate the advantages of this approach. Finally, we summarize and discuss some of the important research issues in light of previous research.     

SOFL: a formal engineering methodology for industrial applications

Formal methods have yet to achieve wide industrial acceptance for several reasons. They are not well integrated into established industrial software processes, their application requires significant abstraction and mathematical skills, and existing tools do not satisfactorily support the entire formal software development process. We have proposed a language called SOFL (Structured-Object-based-formal Language) and a SOFL methodology for system development that attempts to address these problems using an integration of formal methods, structured methods and object oriented methodology. Construction of a system uses structured methods in requirements analysis and specifications, and an object based methodology during design and implementation stages, with formal methods applied throughout the development in a manner that best suits their capabilities. The paper describes the SOFL methodology, which introduces some substantial changes from current formal methods practice. A comprehensive, practical case study of an actual industrial Residential Suites Management System illustrates how SOFL is used     

Formal program construction by transformations-computer-aided,intuition-guided programming

Formal program construction by transformations is a method of software development in which a program is derived from a formal problem specification by manageable, controlled transformation steps which guarantee that the final product meets the initial specification. This methodology has been investigated in the Munich project CIP (computer-aided intuition-guided programming). The research includes the design of a wide-spectrum language specifically tailored to the needs of transformational programming, the construction of a transformation system to support the methodology, and the study of transformation rules and other methodological issues. Particular emphasis has been laid on developing a sound theoretical basis for the overall approach     

Introduction to object-oriented systems engineering.1

Within software development, object-oriented (OO) analysis provides an incremental and iterative approach to guide the requirements definition, design, and development of software-intensive systems. OO analysis uses the Unified Modeling Language (UML) to capture and represent these requirements. UML permits specification of the product independent of programming language or development process. This independent product representation has raised interest in the systems engineering community: OO methods might be a mechanism to unite product development disciplines and remove the gap between the specified and as-built products. The paper discusses the object oriented systems engineering process.     

领域大数据应用开发与运行平台技术研究

随着大数据技术在不同领域的快速应用,构建大数据应用系统的开发与运行一体化平台,降低大数据技术在各行各业应用普及的门槛,为面向领域的大数据应用系统的快捷开发和高效运行提供方法、工具和平台支撑,成为大数据产业发展的迫切需求。由于大数据固有的复杂性、动态性、多样性及其价值独创性,目前尚未形成系统化的大数据软件开发方法,难以满足不同领域对大数据全生命周期处理的多样化需求。大数据时代的软件工程面临的挑战,体现在互为依赖的两方面：面向大数据全生命周期的集成设计开发环境和基于软件生命周期的系统运行分析工具。本文结合特定领域的实际需求,研究面向领域的大数据应用系统开发与运行一体化平台技术,覆盖大数据生命周期（获取、清洗、集成、分析、呈现）以及软件生命周期（设计、开发、运行、优化）,形成自管理、自适应、自优化的平台化解决方案。在此基础上,开展面向装备物联网及气象民生服务的大数据示范应用,以验证平台的有效性。     

Design of Ada Systems Yielding Reusable Components: An Approach Using Structured Algebraic Specification

Our experience with design of Ada¹ software has indicated that a methodology, based on formal algebra, can be developed which integrates the design and management of reusable components with Ada systems design. The methodology requires the use of a specification language, also based on formal algebra, to extend Ada's expressive power for this purpose. We show that certain requirements for the use of Ada packages which cannot be expressed in Ada can be expressed in algebraic specification languages, and that such specifications can then be implemented in Ada.     

Designing secure databases

Security is an important issue that must be considered as a fundamental requirement in information systems development, and particularly in database design. Therefore security, as a further quality property of software, must be tackled at all stages of the development. The most extended secure database model is the multilevel model, which permits the classification of information according to its confidentiality, and considers mandatory access control. Nevertheless, the problem is that no database design methodologies that consider security (and therefore secure database models) across the entire life cycle, particularly at the earliest stages currently exist. Therefore it is not possible to design secure databases appropriately. Our aim is to solve this problem by proposing a methodology for the design of secure databases. In addition to this methodology, we have defined some models that allow us to include security information in the database model, and a constraint language to define security constraints. As a result, we can specify a fine-grained classification of the information, defining with a high degree of accuracy which properties each user has to own in order to be able to access each piece of information. The methodology consists of four stages: requirements gathering; database analysis; multilevel relational logical design; and specific logical design. The first three stages define activities to analyze and design a secure database, thus producing a general secure database model. The last stage is made up of activities that adapt the general secure data model to one of the most popular secure database management systems: Oracle9i Label Security. This methodology has been used in a genuine case by the Data Processing Center of Provincial Government. In order to support the methodology, we have implemented an extension of Rational Rose, including and managing security information and constraints in the first stages of the methodology.     

Deriving engineering software from requirements

With the advent of intelligent computer aided design systems, companies such as Boeing are embarking on an era in which core competitive engineering knowledge and design rationale is being encoded in software systems. The promise of this technology is that this knowledge can be leveraged across many different designs, product families, and even different uses (e.g., generative process planning for manufacturing). The current state of the practice attempts to achieve this goal through the reuse of software components. A fundamental problem with this approach to knowledge sharing and reuse is that what we are trying to reuse is software—the end artifact in a long and complicated process that goes from requirement specifications, through a process of design, to implementations. Knowledge sharing and reuse can not easily and uniformly occur at the software level. So what can be done as an alternative? This paper describes a theory, methodology, language, and tool for the semi-automatic development and maintenance of engineering software from requirement specifications. In essence, this paradigm for software development and maintenance is one that explicitly captures requirement specifications, designs, implementations, and the refinement processes that lead from requirements all the way down to software. By recording this entire refinement history, we stand a better chance of leveraging knowledge for different uses.     

The SDL pattern approach – a reuse-driven SDL design methodology

There are several SDL methodologies that offer full system life-cycle support. Only few of them consider software reuse, not to mention high-level reuse of architecture and design. However, software reuse is a proven software engineering paradigm leading to high quality and reduced development effort. Experience made it apparent that – beyond the more traditional reuse of code – especially high-level reuse of architecture and design (as in the case of design patterns or frameworks) has the potential of achieving more systematic and widespread reuse. This paper presents the SDL pattern approach, a design methodology for distributed systems which integrates SDL-based system development with the pattern paradigm. It supports reuse of design knowledge modeled as SDL patterns and concentrates on the design phase of SDL-based system development. In order to get full life-cycle support, the pattern-based design process can be integrated within existing SDL methodologies.     

Requirements specification via activity diagrams for agent-based systems

Goal-oriented agent systems are increasingly popular for developing complex applications that operate in highly dynamic environments. As with any software these systems have to be designed starting with the specification of system requirements. In this paper, we extend a popular agent design methodology, Prometheus, and improve the understandability and maintainability of requirements by automatically generating UML activity diagrams from existing requirements models; namely scenarios and goal hierarchies. This approach aims to overcome some of the ambiguity present in the current requirements specification in Prometheus and provide more structure for representing variations. Even though our approach is grounded in Prometheus, it can be generalised to all the methodologies that support similar notions in specifying requirements (i.e. notions of goals and scenarios). We present our approach and an evaluation based on user experiments. The evaluation showed that the activity diagram based approach enhances people’s understanding of the requirements, makes it easier to modify requirements, and easier to check them against the detailed design of the agents for coverage.     

A toolset in Java2 for modelling, prototyping and implementing communicating real-time state machines

This paper proposes an approach to the development of real-time systems which depends on Communicating Real-Time State Machines (CRSMs) as the specification language, and on a customisable actor kernel for prototyping, analysis and implementation of a modelled system. CRSMs offer an intuitive and distributed specification of a system in terms of a collection of co-operating state machines interacting with one another through timed CSP-like I/O commands. On the other hand, the underlying actor framework provides a time-sensitive scheduling structure which can be tuned to CSRMs in order to support temporal validation through assertions on the recorded time-stamped event histories. The approach can be practically used through a graphical environment (jCRSM) which has been realised using Java2. The toolset facilitates editing, testing and implementation in Java of CRSM systems. The proposed methodology is novel in that it provides a seamless system development life cycle where the specification, analysis, design and implementation phases are unified by a common representation of machines in terms of actors. The paper demonstrates the use of CRSM based software components by means of examples.     

Requirements-based execution time prediction of a partitioned real-time system using I/O and SLOC estimates

Predicting computer processing requirements of a completed system early in the design and development lifecycle of that system is challenging. Software requirements and avionic or hardware systems often mature in parallel, and, in early stages of design, uncertainty over processing requirements makes determination of processing architecture difficult. Later in the design process, as details become finalized and prototypes are developed, estimations become increasingly more accurate. However, waiting until later in the lifecycle to make architectural changes causes those changes to be more costly and introduces schedule and technical risks. The sooner processing needs are determined and the corresponding system architecture is established, the more easily an appropriate processing platform can be incorporated into the design. This paper describes a novel approach for estimating processor utilization early in the lifecycle of a large, real-time software development project: NASA??s Orion Crew Exploration Vehicle flight software. The approach uses available requirements documentation as a basis of the estimate and decouples input/output (I/O)- and computation-based processing by estimating each separately then combining the results. This approach is unique because it can be used to estimate the execution time for unwritten or partially specified software, in addition to giving a specific contribution for I/O. The methodology for estimating I/O processing is based on quantifying data, while the methodology for estimating algorithmic processing is based on approximated code size. Results can be used as an aid to predict target processor types and quantities, allocate software to processors, predict communication bandwidth utilization, and manage processor margins.