15212910
A software product line architecture for distributed real-time and embedded systems: a separation of concerns approach
This paper presents a separation of concerns approach to solve the tangling problem of functional and Quality of Service (QoS) concerns in traditional Component-based Software Engineering (CBSE) and Software Product Line (SPL) technologies applied to Distributed Real-time and Embedded (DRE) systems. This problem originates from the interchangeability for fulfilling functional and QoS concerns during composition. The approach utilizes the perspective of QoS to design and analyze a set of software systems represented by a collection of QoS systemic paths, which determine how well functional tasks perform in terms of flows of application-specific and functionality-determined information between components. Our approach not only reserves the virtues of reusability, changeability, productivity and expeditiousness that traditional CBSE and SPL technologies possess, but also dedicates the contributions in terms of separation of concerns, design space exploration, fine-grained commonality and reusability evaluation and less subjective feasibility analyses for a component-based SPL.
16252718
QoSPL: A QoS-Driven Software Product Line Engineering Framework for Distributed Real-time and Embedded Systems
The current synergy of Component-Based Software Engineering (CBSE) and Software Product Line Engineering (SPLE) requires evolution to facilitate Distributed Realtime and Embedded (DRE) system construction. Such evolution is driven by inherent Quality of Service (QoS) characteristics in DRE systems. This paper introduces a QoSdriven SPLE framework (QoSPL) as an analysis and design paradigm for constructing a set of DRE systems as a product line. Leveraging separation of concerns, DRE systems are analyzed and designed by a collection of QoS systemic paths, each of which individually determines how well the service performs along the path and as a whole represents a behavioral view of software architecture. The paradigm reduces construction workload from the problems of tangled functional and QoS requirements and abundant infeasible design alternatives, and offers a less subjective QoS evaluation. The adopted formalisms also facilitate high-confidence DRE product line construction.
3093228
T-Clipse: an integrated development environment for two-level grammar
T-Clipse is an Integrated Development Environment (IDE) using Eclipse developed for Two-Level Grammar (TLG), a high-level formal specification language. In our research, given a programming language, TLG is used to specify the syntax and semantics of the language to generate an interpreter for that language. This IDE provides a user-friendly environment for editing and navigation of TLG source codes, as well as parsing and error tracing at the source code level and interpreter generation for programming languages. To build this IDE, we leveraged the extension power of plug-ins in Eclipse as well as a TLG parser prebuilt from an existing lexical analyzer generator and parser generator.
18135743
A clustering entropy-driven approach for exploring and exploiting noisy functions
Linear, Gaussian, fitness proportional, clustering, and Rosca entropies are succinct measures of diversity that have been applied to balance exploration and exploitation in evolutionary algorithms. In previous studies, an entropy-driven approach using linear entropy explicitly balances and/or searches optimal solutions for the selected unimodal and multimodal functions excluding noisy functions. This paper investigates the reasons for such an exception and introduces a clustering entropy-driven approach to solve the problem. Such an approach provides a coarse-grained diversity measure that filters the noise of functions, varies cluster size and categorizes individuals at the genotype level. The experimental results show that the clustering entropy-driven approach further improves the searching results of noisy functions by one more degree.
1399991
Validation of Distributed Real-Time and Embedded System composition in UniFrame
Distributed Real-Time and Embedded (DRE) Systems are widely applied to large scale and mission critical application domains such as avionics systems and medical imaging. Due to the rapid lifecycle and the complexity of design of the systems, there is an urgent demand to manage the development of robust, COTS, and effective software for vendors. The UniFrame project is a unified framework for seamless integration of distributed heterogeneous software components. This paper describes how the UniFrame approach is applicable to DRE software components. Leveraging the Two-Level Grammar (TLG) specification language and the Vienna Development Method (VDM), a formal methodology for developing DRE components and system code generation is developed for UniFrame.
7866306
Two-level assurance of QoS requirements for distributed real-time and embedded systems
Assuring quality of service (QoS) requirements is critical when assembling a distributed real-time and embedded (DRE) system from a repository of existing software and hardware components. This paper presents a two-level approach for assuring satisfaction of QoS requirements in the context of a reduced design space for DRE systems. Techniques from artificial intelligence and statistics are used to fulfill these collective objectives at system assembly time. The result not only lessens the overhead of validation of QoS requirements at run-time, but also reduces the development and integration cost of DRE systems.
2425320
Scalable data aggregation for dynamic events in sensor networks
Computing and maintaining network structures for efficient data aggregation incurs high overhead for dynamic events where the set of nodes sensing an event changes with time. Moreover, structured approaches are sensitive to the waiting-time which is used by nodes to wait for packets from their children before forwarding the packet to the sink. Although structureless approaches can address these issues, the performance does not scale well with the network size. We propose a semi-structured approach that uses a structureless technique locally followed by Dynamic Forwarding on an implicitly constructed packet forwarding structure to support network scalability. The structure, ToD, is composed of multiple shortest path trees. After performing local aggregation, nodes dynamically decide the forwarding tree based on the location of the sources. The key principle behind ToD is that adjacent nodes in a graph will have low stretch in one of these trees in ToD, thus resulting in early aggregation of packets. Based on simulations on a 2000 nodes network and real experiments on a 105 nodes Mica2-based network, we conclude that efficient aggregation in large scale networks can be achieved by our semi-structured approach.
18927685
Developing Quality Software Systems Using the SOFL Formal Engineering Method
Formal Engineering Methods are a bridge from Formal Methods to industrial applications. In this paper I describe the relation between formal engineering methods and formal methods, and present a specific formal engineering method SOFL (Structured Object-Oriented Formal Language) for developing quality software systems. I explain how SOFL can be applied in practice through examples.
14849633
A study of Japanese software process practices and a potential for improvement using SOFL
The goal of this paper is to examine the Japanese experience with the software development process, the challenges they face and how formal engineering methods, in particular SOFL (structured object-oriented formal language), can help overcome these problems. We also recommend additional management tools and documents that can aid organizations in achieving a higher CMM rating through the use of SOFL.
1744079
Object-based analog VLSI vision circuits
Describes two analog VLSI chips that perform object-based computations. The first chip computes length of various contours in an image and the second chip performs figure-ground separation of a scene.<<ETX>>
14515232
An investigation of the approach to specification-based program review through case studies
Software review is an effective means to enhance the quality of software systems. However, traditional review methods emphasize the importance of the way to organize reviews and rely on the quality of the reviewers' experience and personal skills. In this paper we propose a new approach to rigorously reviewing programs based on their formal specifications. The fundamental idea of the approach is to use a formal specification as a standard to check whether all the required functions and properties in the specification are correctly implemented by its program. To help investigate the effectiveness and the weakness of the approach, we conduct two case studies of reviewing two program systems that implement the same formal specification of "A Research Management Policy" using different strategies, and present the evaluation of the case studies. The results show that the review approach is effective in detecting faults when the reviewer is different from the programmer, but less effective when the reviewer is the same as the programmer.