Reconciling system requirements and runtime behavior

With the growing complexity of complex software-intensive systems, some new features emerge such as logical complexity, boundary erosion and failure normalization, which bring new challenges for software dependability assurance. As a result, there is urgent necessity to analyze the failure mechanism of these systems in order to ensure the dependability of complex software-intensive systems. Research indicates that because of the emerging new features, the failure mechanism of complex software-intensive systems is related closely to the system's runtime states and behaviors. But direct analysis of failure mechanism on actual complex software-intensive systems is costly and nearly impossible because of their large scale. So failure mechanism analysis was normally performed on abstract models of real systems. However, current modelling methods are insufficient for describing the system's internal interaction, software/hardware interaction behavior, runtime behavior comprehensively. So it is necessary to propose a new modelling method to support the description of these new features. This paper proposes a method for constructing runtime models for complex software-intensive systems which takes into consideration internal interaction behavior, interaction behavior between software and hardware on system boundary as well as dynamic runtime behavior. The proposed method includes a static structure model to describe the static structure property of the system, a software/hardware interaction model to describe the interaction characteristics between hardware and software on system boundary and a dynamic runtime behavior model to describe the dynamic features of runtime behavior formally. An example is provided to demonstrate how to use the proposed method and its implication for failure mechanism analysis in complex software-intensive systems is discussed.

Maintenance of embedded software systems is faced with multiple challenges, including the exploration and analysis of the actual system's runtime behavior. As a fundamental technique, tracing can be used to capture data about runtime behavior as a whole, and represents one of the few methods to observe and record data about embedded systems within their production environments. In this paper we present a software-based, function-boundary tracing approach for embedded software systems. It uses static binary instrumentation, which implies only lightweight memory and performance overheads. To further reduce these overheads, instrumentation can be configured per trace, i.e., activated only for a specified group of functions without having to recompile the system. The technique can be characterized by its robust implementation and its versatile usage. It is complemented by a visualization framework that allows for analysis and exploration of a system's runtime behavior, e.g., to examine thread interaction. To show the technique's applicability, we conclude with a case study that has been applied to an industrial embedded software system.

An integrated real-time tool set is described that consists of a schedulability analyzer and a real-time monitor/debugger for the ARTS kernel, which is being built for a distributed real-time testbed. The schedulability analyzer, called Scheduler 1-2-3, is an X11 window-based interactive tool and can verify whether the given real-time tasks can meet their deadlines under a specific scheduling policy. An advanced real-time monitor, ARM, also runs on the X11 window and visualizes the target system's runtime behavior in real time. ARM can be used with Scheduler 1-2-3 to analyze simulated runs and its monitorability. >

Recently, more attention is paid to the researches and practices on how to use software architecture in software maintenance and evolution to reduce their complexity and cost. The key in such architecture-based maintenance and evolution is to recover software architecture from existing systems. Almost all studies on architecture recovery focus on analyzing the source code and other documents. Such recovered software architecture can hardly capture runtime states and behaviors of the system. At the same time, current work pays little attention on how to change the system directly via manipulating the recovered software architecture. This paper presents a novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture. Containing much more details than the designed software architecture, the recovered software architecture can accurately and thoroughly describe the actual states and behaviors of the runtime system. It can be described formally with the extension of traditional architecture description language, which enables the recovered software architecture to absorb the semantics embedded in the designed software architecture. The recovered software architecture can be represented as multiple views so as to help different users to control the complexity from different concerns. Based on the reflective ability of the component framework, the recovered software architecture is up-to-date at any time and changes made on it will immediately lead to the corresponding changes in the runtime system. The approach presented in this paper is demonstrated on PKUAS, a reflective J2EE (Java 2 Platform Enterprise Edition) application server, and the performance is also evaluated.

Towards a Graphical Tool for Refining User to System Requirements

In task-parallel programs, diverse activities can take place concurrently, and communication and synchronization patterns are complex and not easily predictable. Previous work has identified compositionality as an important design principle for task-parallel programs. In this paper, we discuss alternative approaches to the realization of this principle. We first provide a review and critical analysis of Strand, an early compositional programming language. We examine the strengths of the Strand approach and also its weaknesses, which we attribute primarily to the use of a specialized language. Then, we present an alternative programming language framework that overcomes these weaknesses. This framework uses simple extensions to existing sequential languages (C++ and Fortran) and a common runtime system to provide a basis for the construction of large, task-parallel programs. We also discuss the runtime system techniques required to support these languages on parallel and distributed computer systems.

Devising a system requirements specification is a challenging task. Even after several decades of system development research, specifications for large-scale, widely-used systems remain difficult. In this paper, we suggest a first step toward a requirements specification through a stakeholder involvement approach with game elements. We report preliminary findings from a practice case in which our methods are applied to the requirement specification phase of a project management system. The analysis showed that our game approach fostered innovative idea generation and captured implicit user expectations, and as a result provided a list of requirements from other perspectives than those of conventional specification analysis. The granularities of extracted system requirements need to be refined and transferred to detailed requirements for developers to use, however, our results imply that our stakeholder involvement method with game elements can be effectively utilized as a first step towards requirement specification.

The requirements of a system describe what the user expects from the system – in other words, what the system will do for the user. When defining the requirements of a system, the system should be viewed as a black box, so that only the external characteristics of the system are considered. Both functional and nonfunctional requirements need to be considered. Requirements modeling consists of requirements analysis and requirements specification. Use case modeling is an approach for describing the functional requirements of the system, as described in this chapter. The system's data requirements in terms of the information that needs to be stored by the system are determined using static modeling, as described in Chapter 7. The inputs to the system and the outputs from the system are described initially in the use case models and then specified in more detail during static modeling. This chapter gives an overview of software requirements analysis and specification in Section 6.1. It then goes on to describe the use case approach to defining functional requirements, as well as how to extend use cases to describe nonfunctional requirements. This chapter describes the concepts of actors and use cases , and then goes on to describe use case relationships, in particular, the include and extend relationships. Section 6.2 gives an overview of use case modeling followed by an example of a simple use case. Section 6.3 then describes actors and their role in use case modeling.

: The focus of Taskable Reactive Agent Communities (TRAC) project was to develop mixed-initiative technology to enable humans to supervise and manage teams of agents as they perform tasks in dynamic environments. TRAC technology would enable users to task agent communities in a high-level language that provides both descriptions of goals to be satisfied and boundaries on agent behavior. The TRAC approach can be viewed as providing a form of high-level process management technology that enables flexible human control of agent communities. In particular, the TRAC framework is intended to support applications where processes are distributed and automated, but where human guidance can improve performance and increase flexibility. The technical work for the project focused on identifying useful categories of guidance for directing agents, designing languages for expressing guidance, and developing techniques for operationalizing guidance into constraints that influence agent behavior. Because users may provide incompatible or unsatisfiable guidance to agents, the work also encompassed techniques for detecting and resolving conflicting guidance. The TRAC implementation was used as the basis for a demonstration system called TIGER (TRAC Intelligence Gathering and Emergency Response), which focused on the problem of multiagent intelligence gathering in the wake of a simulated natural disaster. Within TIGER, a human supervisor can delegate tasks to agents while providing guidance to control their runtime behavior.

: Optimally partitioning application and file system functionality within a cluster of clients and servers is a difficult problem due to dynamic variations in application behavior, resource availability and workload mixes. This paper presents ABACUS, a run-time system that monitors and dynamically changes function placement for applications that manipulate large data sets. Several examples of data-intensive workloads are used to show the importance of proper function placement and its dependence on dynamic runtime characteristics, with performance differences frequently reaching 2-10X. We evaluate how well the ABACUS prototype adapts to run-time system behavior, including both long-term variation (e.g., filter selectivity) and short-term variation (e.g.,multi-phase applications and inter-application resource contention). Our experiments with ABACUS indicate that it is possible to adapt in all of these situations and that the adaptation converges most quickly in those cases where the performance impact is most significant.

Recently, business transformation towards the used of Information and Communication Technology (ICT) is a necessity toward rapid industries and the paradigm shifted to sustain business competitiveness. The holistic electronic approach is one of business innovations, especially in handling a lot of tender documentations and process in an electronic environment namely as e-Tendering. Unfortunately, the existing tender process transformation in the electronic approach is not properly followed certain standard and guideline, especially in establishing a good e-Tendering functional requirements specification to ensure the organizations would be in the best served. This is important to ensure a good e-Tendering system can be developed by e-Tendering developers based on a good e-Tendering functional requirement specifications. The requirements specification is a process of documenting user and system requirements. Commonly, user and system requirements should be clear, unambiguous, easy to understand, complete, and consistent. In practice, this is difficult to achieve due to interpretation of the requirements in different ways by stakeholders, which are often inherent conflicts and inconsistencies of the requirements. The implementation of the existing e-tendering still remains uncertainties, especially in defining the functional requirements of the e-tendering system. Therefore, this study aims to construct the e-Tendering functional requirement model using requirement template in natural language representation approach. Moreover the development of this system requirement model may provide a consistency to the requirements representation. The study uses UN/CEFACT Business Standard of the e-Tendering Business. The identified functional requirements are designed by using Requirement Template to ensure the reliability and understandability of requirements. Besides, the proposed functional requirements is constructed by adapting the natural language and verified by expert review approaches. As a result, this study proposed a functional requirements specification of the e-Tendering that contains detailed description which can be referred by software practitioners in developing a secure e-tendering system effectively.

Software requirements errors are considered to account for a majority of software failures, and a number of accidents happen because of software requirements errors. The requirements specification of transportation cyber physical system is particularly critical because we must provide high safety of these transportation systems. Therefore, techniques to provide adequate requirements specification and to find errors early are of great importance. Transportation cyber physical systems contain three parts: physical parts, communication parts and computation parts. Existing methods cannot be well suited for requirement specification and modeling of transportation cyber physical systems. In this paper, we extend the AADL to model the behavior characteristic, continuous dynamic features and spatial-temporal requirements of transportation cyber physical systems. We propose a method to transform the rule of Cellular Automata to AADL model for modeling spatial-temporal requirements and we propose an approach to describe the continuous dynamic features in AADL and transform the Modelica model to AADL model. The proposed method is illustrated by Vehicular Ad-hoc Network.

Surface Stabilization of O3-type Layered Oxide Cathode to Protect the Anode of Sodium Ion Batteries for Superior Lifespan.

As of 2011, the Android market has already surpassed the Apple App Store in number of applications. Along with this increase in applications, also comes an increase in number of malicious applications. In response, there has been extensive research done with behavioral analysis and detection methods using system calls, CPU usage, and anomaly-based detection. In this paper, we extend upon these previous works by using logcat and strace outputs to generate runtime datasets of both malicious and benign applications. Using these datasets, we generate feature sets to be used for classification. We test the effectiveness of both a Random Forest classifier and a Support Vector Machine on this feature set. We see the Random Forest classifier perform well with true positive rates exceeding 90% while maintaining a false positive rate less than 6%.

This paper discusses requirements for Ada1 compilers and associated tools used for real-time embedded weapons systems (EWS) development. The requirements have been developed over a period of several years by embedded systems developers at Honeywell Inc. and Alliant Techsystems Inc. Requirements for the run time system, compiler-generated code, and host tools such as linkers are presented. A short rationale statement is provided with each specific requirement.