Downloads & Free Reading Options - Results

The current effort was done to assess the utility of surface acoustic wave (SAW) detectors for analyzing multicomponent gaseous mixtures in real time. Tasks included surveying currently available SAW detector capability, selecting several candidate SAW coating materials, fabricating vapor monitors, and testing for sensitivity and selectivity. An assessment of possible SAW designs for real- time analysis of multicomponent mixtures is attempted. Surface acoustic wave detector, Real-time multicomponent vapor analysis.

by Sebastian Sumpf At: FOSDEM 2018 Room: AW1.126 Scheduled start: 2018-02-03 11:05:00+01 Source: https://www.youtube.com/watch?v=dElvX7bILY8 Uploader: FOSDEM

by Sebastian Sumpf At: FOSDEM 2018 Room: AW1.126 Scheduled start: 2018-02-03 11:05:00+01 Source: https://www.youtube.com/watch?v=dElvX7bILY8 Uploader: FOSDEM

This paper addresses the monitoring of logic-independent linear-time user-provided properties in multi-threaded component-based systems. We consider intrinsically independent components that can be executed concurrently with a centralized coordination for multiparty interactions. In this context, the problem that arises is that a global state of the system is not available to the monitor. A naive solution to this problem would be to plug in a monitor which would force the system to synchronize in order to obtain the sequence of global states at runtime. Such a solution would defeat the whole purpose of having concurrent components. Instead, we reconstruct on-the-fly the global states by accumulating the partial states traversed by the system at runtime. We define transformations of components that preserve their semantics and concurrency and, at the same time, allow to monitor global-state properties. Moreover, we present RVMT-BIP, a prototype tool implementing the transformations for monitoring multi-threaded systems described in the BIP (Behavior, Interaction, Priority) framework, an expressive framework for the formal construction of heterogeneous systems. Our experiments on several multi-threaded BIP systems show that RVMT-BIP induces a cheap runtime overhead.

This paper addresses the monitoring of logic-independent linear-time user-provided properties in multi-threaded component-based systems. We consider intrinsically independent components that can be executed concurrently with a centralized coordination for multiparty interactions. In this context, the problem that arises is that a global state of the system is not available to the monitor. A naive solution to this problem would be to plug in a monitor which would force the system to synchronize in order to obtain the sequence of global states at runtime. Such a solution would defeat the whole purpose of having concurrent components. Instead, we reconstruct on-the-fly the global states by accumulating the partial states traversed by the system at runtime. We define transformations of components that preserve their semantics and concurrency and, at the same time, allow to monitor global-state properties. Moreover, we present RVMT-BIP, a prototype tool implementing the transformations for monitoring multi-threaded systems described in the BIP (Behavior, Interaction, Priority) framework, an expressive framework for the formal construction of heterogeneous systems. Our experiments on several multi-threaded BIP systems show that RVMT-BIP induces a cheap runtime overhead.

This paper addresses the monitoring of logic-independent linear-time user-provided properties in multi-threaded component-based systems. We consider intrinsically independent components that can be executed concurrently with a centralized coordination for multiparty interactions. In this context, the problem that arises is that a global state of the system is not available to the monitor. A naive solution to this problem would be to plug in a monitor which would force the system to synchronize in order to obtain the sequence of global states at runtime. Such a solution would defeat the whole purpose of having concurrent components. Instead, we reconstruct on-the-fly the global states by accumulating the partial states traversed by the system at runtime. We define transformations of components that preserve their semantics and concurrency and, at the same time, allow to monitor global-state properties. Moreover, we present RVMT-BIP, a prototype tool implementing the transformations for monitoring multi-threaded systems described in the BIP (Behavior, Interaction, Priority) framework, an expressive framework for the formal construction of heterogeneous systems. Our experiments on several multi-threaded BIP systems show that RVMT-BIP induces a cheap runtime overhead.

Individual machines in flexible production lines explicitly expose capabilities at their interfaces by means of parametric skills. Given such a set of configurable machines, a line integrator is faced with the problem of finding and tuning parameters for each machine such that the overall production line implements given safety and temporal requirements in an optimized and robust fashion. We formalize this problem of configuring and orchestrating flexible production lines as a parameter synthesis problem for systems of parametric timed automata, where interactions are based on skills. Parameter synthesis problems for interaction-level LTL properties are translated to parameter synthesis problems for state-based safety properties. For safety properties, synthesis problems are solved by checking satisfiability of $\exists\forall$SMT constraints. For constraint generation, we provide a set of computationally cheap over-approximations of the set of reachable states, together with fence constructions as sufficient conditions for safety formulas. We demonstrate the feasibility of our approach by solving typical machine configuration problems as encountered in industrial automation.

Current trends in the software development are focused on creating systems by integrating previously developed software components. This approach aids in the reusability of the code and helps to reduce the cost of software development. In addition to the functionality a component offers, it may contain the necessary code for measuring how well the functionality will be achieved during the execution. This gives rise to the notion of quality of service (QoS) offered by a component -- latency, throughput, capacity, precision, etc., are a few examples of QoS parameters. Many applications, such as multi-media, emphasize and require a certain level of the QoS offered by components. Thus, it is critical to model the QoS, at an appropriate level of an abstraction, during the modeling of component-based systems. Such a modeling will not only assist the component developers but also emphasize the need for integrating the QoS during the development and implementation phases of the software design. In this thesis, an approach based on a unified framework (UniFrame) is proposed to model the QoS parameters in component-based systems. The approach involves QoS concepts relevant for specifying QoS, a UML profile for representing the concepts, integrating the QoS specification with the functional specification and mapping the specification manually onto the code of the component.

The objectives of this project are to address challenges of constructing large-scale DoD software intensive systems by constructing an integrated modeling and specification framework that can support software product-line development based on widely-used component middleware frameworks that will likely form the basis of future DoD systems. This document provides the final performance report on this project.

The objectives of this project are to address challenges of constructing large-scale DoD software intensive systems by constructing an integrated modeling and specification framework that can support software product-line development based on widely-used component middleware frameworks that will likely form the basis of future DoD systems. This document provides the final performance report on this project.

We present a novel method for efficient direct integration of gravitational N-body systems with a large variation in characteristic time scales. The method is based on a recursive and adaptive partitioning of the system based on the connected components of the graph generated by the particle distribution combined with an interaction-specific time step criterion. It uses an explicit and approximately time-symmetric time step criterion, and conserves linear and angular momentum to machine precision. In numerical tests on astrophysically relevant setups, the method compares favourably to both alternative Hamiltonian-splitting integrators as well as recently developed block time step-based GPU-accelerated Hermite codes. Our reference implementation is incorporated in the HUAYNO code, which is freely available as a part of the AMUSE framework.

Reconfiguration paths express sequences of successive reconfiguration operations within a component-based approach allowing dynamic reconfigurations. We use constructs from regular expressions-pin particular, alternatives-to introduce multiple reconfiguration paths. We show how to put into action procedures allowing architectural, event, and temporal properties to be proved. Our method, related to finite state automata and using marking techniques, generalises what we did within previous work, where the regular expressions we processed were more restricted. But we can only deal with a subset of first-order logic formulas.

We present a novel fault detection method for application in component-based robotic systems. In contrast to existing work, our method specifically addresses faults in the software system of the robot using a data-driven methodology which exploits the inter-process communication of the system. This enables an application of the approach without expert knowledge or availability of complex software models. We specifically focus on performance bugs, which slowly degrade the performance of the system and are thereby harder to detect but also most valuable for automatic recovery. Using a data set recorded on a RoboCup@Home platform we demonstrate the performance and applicability of our method and analyze the types of faults that can be detected by the method.

The overall objectives of this project were to develop approaches to program comprehension that would provide significant added benefits in many aspects of software engineering. As one part of that effort, the RESOLVE/ACTI framework for a software component composition technology was developed. The technology focuses on development of software components that can be reused and a composition discipline that helps in creating programs whose properties can be efficiently reasoned about. As another part of the effort, a device comprehension framework called Functional Representation was applied, and its utility shown for software architecture comprehension, legacy software reengineering and representation of system requirements.

The overall objectives of this project were to develop approaches to program comprehension that would provide significant added benefits in many aspects of software engineering. As one part of that effort, the RESOLVE/ACTI framework for a software component composition technology was developed. The technology focuses on development of software components that can be reused and a composition discipline that helps in creating programs whose properties can be efficiently reasoned about. As another part of the effort, a device comprehension framework called Functional Representation was applied, and its utility shown for software architecture comprehension, legacy software reengineering and representation of system requirements.

This paper introduces a new technique for dynamic verification of component-based real-time systems based on statistical inference. Verifying such systems requires checking two types of properties: functional and real-time. For functional properties, a standard approach for ensuring correctness is Design by Contract: annotating programs with executable pre- and postconditions. We extend contracts for specifying real-time properties. In the industry, components are often bought from vendors and meant to be used off-the-shelf which makes it very difficult to determine their execution times and express related properties. We present a solution to this problem by using statistical inference for estimating the properties. The contract framework allows application developers to express contracts like "the execution time of component $X$ lies within $\gamma$ standard deviations from the mean execution time". Experiments based on industrial case studies show that this framework can be smoothly integrated into existing control applications, thereby increasing their reliability while having an acceptable execution time overhead (less than 10%).

Runtime enforcement is an increasingly popular and effective dynamic validation technique aiming to ensure the correct runtime behavior (w.r.t. a formal specification) of systems using a so-called enforcement monitor. In this paper we introduce runtime enforcement of specifications on component-based systems (CBS) modeled in the BIP (Behavior, Interaction and Priority) framework. BIP is a powerful and expressive component-based framework for formal construction of heterogeneous systems. However, because of BIP expressiveness, it remains difficult to enforce at design-time complex behavioral properties. First we propose a theoretical runtime enforcement framework for CBS where we delineate a hierarchy of sets of enforceable properties (i.e., properties that can be enforced) according to the number of observational steps a system is allowed to deviate from the property (i.e., the notion of k-step enforceability). To ensure the observational equivalence between the correct executions of the initial system and the monitored system, we show that i) only stutter-invariant properties should be enforced on CBS with our monitors, ii) safety properties are 1-step enforceable. Given an abstract enforcement monitor (as a finite-state machine) for some 1-step enforceable specification, we formally instrument (at relevant locations) a given BIP system to integrate the monitor. At runtime, the monitor observes and automatically avoids any error in the behavior of the system w.r.t. the specification. Our approach is fully implemented in an available tool that we used to i) avoid deadlock occurrences on a dining philosophers benchmark, and ii) ensure the correct placement of robots on a map.

We present algorithms to synthesize component-based systems that are safe and deadlock-free using priorities, which define stateless-precedence between enabled actions. Our core method combines the concept of fault-localization (using safety-game) and fault-repair (using SAT for conflict resolution). For complex systems, we propose three complementary methods as preprocessing steps for priority synthesis, namely (a) data abstraction to reduce component complexities, (b) alphabet abstraction and #-deadlock to ignore components, and (c) automated assumption learning for compositional priority synthesis.

Component-oriented and service-oriented approaches have gained a strong enthusiasm in industries and academia with a particular interest for service-oriented approaches. A component is a software entity with given functionalities, made available by a provider, and used to build other application within which it is integrated. The service concept and its use in web-based application development have a huge impact on reuse practices. Accordingly a considerable part of software architectures is influenced; these architectures are moving towards service-oriented architectures. Therefore applications (re)use services that are available elsewhere and many applications interact, without knowing each other, using services available via service servers and their published interfaces and functionalities. Industries propose, through various consortium, languages, technologies and standards. More academic works are also undertaken concerning semantics and formalisation of components and service-based systems. We consider here both streams of works in order to raise research concerns that will help in building quality software. Are there new challenging problems with respect to service-based software construction? Besides, what are the links and the advances compared to distributed systems?

Component-oriented and service-oriented approaches have gained a strong enthusiasm in industries and academia with a particular interest for service-oriented approaches. A component is a software entity with given functionalities, made available by a provider, and used to build other application within which it is integrated. The service concept and its use in web-based application development have a huge impact on reuse practices. Accordingly a considerable part of software architectures is influenced; these architectures are moving towards service-oriented architectures. Therefore applications (re)use services that are available elsewhere and many applications interact, without knowing each other, using services available via service servers and their published interfaces and functionalities. Industries propose, through various consortium, languages, technologies and standards. More academic works are also undertaken concerning semantics and formalisation of components and service-based systems. We consider here both streams of works in order to raise research concerns that will help in building quality software. Are there new challenging problems with respect to service-based software construction? Besides, what are the links and the advances compared to distributed systems?

Component-oriented and service-oriented approaches have gained a strong enthusiasm in industries and academia with a particular interest for service-oriented approaches. A component is a software entity with given functionalities, made available by a provider, and used to build other application within which it is integrated. The service concept and its use in web-based application development have a huge impact on reuse practices. Accordingly a considerable part of software architectures is influenced; these architectures are moving towards service-oriented architectures. Therefore applications (re)use services that are available elsewhere and many applications interact, without knowing each other, using services available via service servers and their published interfaces and functionalities. Industries propose, through various consortium, languages, technologies and standards. More academic works are also undertaken concerning semantics and formalisation of components and service-based systems. We consider here both streams of works in order to raise research concerns that will help in building quality software. Are there new challenging problems with respect to service-based software construction? Besides, what are the links and the advances compared to distributed systems?

Formal methods are widely recognized as a powerful engineering method for the specification, simulation, development, and verification of distributed interactive systems. However, most formal methods rely on a two-valued logic, and are therefore limited to the axioms of that logic: a specification is valid or invalid, component behavior is realizable or not, safety properties hold or are violated, systems are available or unavailable. Especially when the problem domain entails uncertainty, impreciseness, and vagueness, the appliance of such methods becomes a challenging task. In order to overcome the limitations resulting from the strict modus operandi of formal methods, the main objective of this work is to relax the boolean notion of formal specifications by using fuzzy logic. The present approach is based on Focus theory, a model-based and strictly formal method for componentbased interactive systems. The contribution of this work is twofold: i) we introduce a specification technique based on fuzzy logic which can be used on top of Focus to develop formal specifications in a qualitative fashion; ii) we partially extend Focus theory to a fuzzy one which allows the specification of fuzzy components and fuzzy interactions. While the former provides a methodology for approximating I/O behaviors under imprecision, the latter enables to capture a more quantitative view of specification properties such as realizability.

The significance of brain computer interface (BCI) systems is immensely high, especially for disabled people and patients with nervous system failure. Therefore, in this study, adaptive filtering-based component analysis (AFCA) model is presented to enhance target box identification efficiency at varied flickering frequencies in a visual stimulation process by efficient acquisition of electroencephalogram (EEG) signals for the application of steady-state visually evoked potential based BCI system. Furthermore, optimization of proposed AFCA model is performed based on the maximized reproducibility of correlated components. A multimedia authoring and management using your eyes and mind (MAMEM) steady-state visual evoked potential (SSVEP) dataset is utilized for efficient training of EEG signals and background entities are eliminated using adaptive filters in a pre-processing stage. Additionally, spatial filtering components are obtained to detect target flickering box based on the obtained quality features. Performance is measured by acquisition of SSVEP signals in terms of reconstruction efficiency, classification accuracy and information transfer rate (ITR) using proposed AFCA model. Mean classification accuracy for all 11 subject is 93.48% and ITR is 308.23 bpm. Further, classification accuracy is relatively higher than various SSVEP classification algorithms.

Service robots are complex, heterogeneous, software intensive systems built from components. Recent robotics research trends mainly address isolated capabilities on functional level. Non-functional properties, such as responsiveness or deterministic behavior, are addressed only in isolation (if at all). We argue that handling such non-functional properties on system level is a crucial next step. We claim that precise control over application-specific, dynamic execution and interaction behavior of functional components -- i.e. clear computation and communication semantics on model level without hidden code-defined parts -- is a key ingredient thereto. In this paper, we propose modeling concepts for these semantics, and present a meta-model which (i) enables component developers to implement component functionalities without presuming application-specific, system-level attributes, and (ii) enables system integrators to reason about causal dependencies between components as well as system-level data-flow characteristics. This allows to control data-propagation semantics and system properties such as end-to-end latencies during system integration without breaking component encapsulation.

We present a taxonomy and an algebra for attack patterns on component-based operating systems. In a multilevel security scenario, where isolation of partitions containing data at different security classifications is the primary security goal and security breaches are mainly defined as undesired disclosure or modification of classified data, strict control of information flows is the ultimate goal. In order to prevent undesired information flows, we provide a classification of information flow types in a component-based operating system and, by this, possible patterns to attack the system. The systematic consideration of informations flows reveals a specific type of operating system covert channel, the covert physical channel, which connects two former isolated partitions by emitting physical signals into the computer's environment and receiving them at another interface.

CoInDiVinE is a tool for parallel distributed model checking of interactions among components in hierarchical component-based systems. The tool extends the DiVinE framework with a new input language (component-interaction automata) and a property specification logic (CI-LTL). As the language differs from the input language of DiVinE, our tool employs a new state space generation algorithm that also supports partial order reduction. Experiments indicate that the tool has good scaling properties when run in parallel setting.

Adaptation of software components is an important issue in Component Based Software Engineering (CBSE). Building a system from reusable or Commercial-Off-The-Shelf (COTS) components introduces a set of problems, mainly related to compatibility and communication aspects. On one hand, components may have incompatible interaction behavior. This might require to restrict the system's behavior to a subset of safe behaviors. On the other hand, it might be necessary to enhance the current communication protocol. This might require to augment the system's behavior to introduce more sophisticated interactions among components. We address these problems by enhancing our architectural approach which allows for detection and recovery of incompatible interactions by synthesizing a suitable coordinator. Taking into account the specification of the system to be assembled and the specification of the protocol enhancements, our tool (called SYNTHESIS) automatically derives, in a compositional way, the glue code for the set of components. The synthesized glue code implements a software coordinator which avoids incompatible interactions and provides a protocol-enhanced version of the composed system. By using an assume-guarantee technique, we are able to check, in a compositional way, if the protocol enhancement is consistent with respect to the restrictions applied to assure the specified safe behaviors.

Within a component-based approach allowing dynamic reconfigurations, sequences of successive reconfiguration operations are expressed by means of reconfiguration paths, possibly infinite. We show that a subclass of such paths can be modelled by finite state automata. This feature allows us to use techniques related to model-checking to prove some architectural, event, and temporal properties related to dynamic reconfiguration. Our method is proved correct w.r.t. these properties' definition.

We present Component-Based Simplex Architecture (CBSA), a new framework for assuring the runtime safety of component-based cyber-physical systems (CPSs). CBSA integrates Assume-Guarantee (A-G) reasoning with the core principles of the Simplex control architecture to allow component-based CPSs to run advanced, uncertified controllers while still providing runtime assurance that A-G contracts and global properties are satisfied. In CBSA, multiple Simplex instances, which can be composed in a nested, serial or parallel manner, coordinate to assure system-wide properties. Combining A-G reasoning and the Simplex architecture is a challenging problem that yields significant benefits. By utilizing A-G contracts, we are able to compositionally determine the switching logic for CBSAs, thereby alleviating the state explosion encountered by other approaches. Another benefit is that we can use A-G proof rules to decompose the proof of system-wide safety assurance into sub-proofs corresponding to the component-based structure of the system architecture. We also introduce the notion of coordinated switching between Simplex instances, a key component of our compositional approach to reasoning about CBSA switching logic. We illustrate our framework with a component-based control system for a ground rover. We formally prove that the CBSA for this system guarantees energy safety (the rover never runs out of power), and collision freedom (the rover never collides with a stationary obstacle). We also consider a CBSA for the rover that guarantees mission completion: all target destinations visited within a prescribed amount of time.

We present Component-Based Simplex Architecture (CBSA), a new framework for assuring the runtime safety of component-based cyber-physical systems (CPSs). CBSA integrates Assume-Guarantee (A-G) reasoning with the core principles of the Simplex control architecture to allow component-based CPSs to run advanced, uncertified controllers while still providing runtime assurance that A-G contracts and global properties are satisfied. In CBSA, multiple Simplex instances, which can be composed in a nested, serial or parallel manner, coordinate to assure system-wide properties. Combining A-G reasoning and the Simplex architecture is a challenging problem that yields significant benefits. By utilizing A-G contracts, we are able to compositionally determine the switching logic for CBSAs, thereby alleviating the state explosion encountered by other approaches. Another benefit is that we can use A-G proof rules to decompose the proof of system-wide safety assurance into sub-proofs corresponding to the component-based structure of the system architecture. We also introduce the notion of coordinated switching between Simplex instances, a key component of our compositional approach to reasoning about CBSA switching logic. We illustrate our framework with a component-based control system for a ground rover. We formally prove that the CBSA for this system guarantees energy safety (the rover never runs out of power), and collision freedom (the rover never collides with a stationary obstacle). We also consider a CBSA for the rover that guarantees mission completion: all target destinations visited within a prescribed amount of time.

Network Centric Warfare poses new challenges to C4ISR systems: future systems must provide access to a homogenous information and service space for a broad spectrum of users whose computation and communication resources vary and whose location may change frequently. We propose a design schema for network-based, service-oriented C4ISR systems and present a base component upon which such systems can be built on. From a user's point of view, the base component provides access to all services (i.e., applications, information sources, etc.) relevant for the current mission. From a technical perspective, these services are software modules which are distributed in a network and interact via well-defined interfaces. A main feature of our base component is that it is load-scalable: if the communication capacity between a user device and the network is insufficient or degrades during an operation, the base component may react to the new situation by moving computational load from the network into the user device. Under certain circumstances this re-balancing of computational load reduces the required communication capacity so that the overall system maintains a tolerable level of operability.

Component-based software engineering has been a dream for at least 30 years, beginning with Doug McIlroy's seminal presentation at the 1968 NATO Conference in Garmisch) The dream is rapidly becoming a reality with the advent of component interoperability standards such as ActiveX and JavaBeans, and middleware infrastructures such as NET, DCOM, and CORBA. Both civilian and military software development efforts stand to reap enormous benefits from this technology, in terms of reduced time-to-deployment, reduced development costs, increased productivity, and increased tolerance for complexity. While existing component technologies provide the basic building blocks for a component-based style of development, they still lack the fundamental mechanisms needed to ensure that systems are composed in a manner that ensures the integrity of component interactions. This research has been dedicated to investigating such fundamental mechanisms, In particular, the research has created mechanisms for specifying and checking component compositions in distributed component-based software systems. The research was conducted along two avenues: developing architectural foundations for developing component-based software; and exploiting and extending component standards to support constraint checking. The results of these two avenues of research are described further below. The authors first briefly discuss each of the two research avenues and the projects that have resulted from pursuing these they list the significant results achieved by each of the project. The publications that have been produced by this research are listed fully in Section 4.

COTS components are typically viewed as black-boxes; input and output information is supplied in their interfaces. In this paper we argue that interfaces provide insufficient information for many analysis purposes and suggest analysis-related annotations be supplied with components. We center our discussion on static dependence analysis. We use an extensible language to annotate components and perform dependence analysis over these descriptions. We propose that component annotations be certified thereby providing a base for certifiable analysis.

Australia's Strategic Policy assigns the highest capability development priority to the achievement of the knowledge edge over our adversaries and identifies a single Command Support System that exhibits flexibility, cost-effectiveness, robustness and adaptivity as being an important enabler of the knowledge edge. This emphasis on the knowledge edge is reinforced in the Defence 2000 White Paper 2, which states that the knowledge edge 'will be the foundation of our military capability over the coming decades'. The Software Systems Engineering (SSE) group of ITD is currently conducting research into new software engineering principles and practices, collectively referred to as component-based software engineering (CBSE), which are expected to meet the requirements of cost-effectiveness and flexibility in the development of command support systems. In addition, knowledge-based techniques, and in particular intelligent agents, provide the opportunity to incorporate adaptivity and robustness into software systems through the use of machine-learning, automated reasoning and encapsulation of domain knowledge. In this paper we outline an extension of the Software Systems Engineering Group's research into CBSE to investigate ways in which intelligent agents can be used to exploit the combined advantages of component-based software engineering and know ledge-based techniques for the development of software for military applications.

Australia's Strategic Policy assigns the highest capability development priority to the achievement of the knowledge edge over our adversaries and identifies a single Command Support System that exhibits flexibility, cost-effectiveness, robustness and adaptivity as being an important enabler of the knowledge edge. This emphasis on the knowledge edge is reinforced in the Defence 2000 White Paper 2, which states that the knowledge edge 'will be the foundation of our military capability over the coming decades'. The Software Systems Engineering (SSE) group of ITD is currently conducting research into new software engineering principles and practices, collectively referred to as component-based software engineering (CBSE), which are expected to meet the requirements of cost-effectiveness and flexibility in the development of command support systems. In addition, knowledge-based techniques, and in particular intelligent agents, provide the opportunity to incorporate adaptivity and robustness into software systems through the use of machine-learning, automated reasoning and encapsulation of domain knowledge. In this paper we outline an extension of the Software Systems Engineering Group's research into CBSE to investigate ways in which intelligent agents can be used to exploit the combined advantages of component-based software engineering and know ledge-based techniques for the development of software for military applications.

This chapter introduces the UniFrame approach to creating high quality computing systems from heterogeneous components distributed over a network. It describes how this approach employs a unifying framework for specifying such systems to unite the concepts of service-oriented architectures, a component-based software engineering methodology and a mechanism for automatically finding components on a network in order to assemble a specified system. UniFrame employs a formal specification language to define the components and serve as a basis for generating glue/wrapper code that connects heterogeneous components. It also provides a high level language for the system developer to use for inserting code in a created system to validate it empirically and estimate the quality of service it supports. The chapter demonstrates how a comprehensive approach, which involves the practicing community as well as technical experts, can lead to solutions of many of the difficulties inherent in constructing distributed computing systems.

This report discusses issues related to the methods and tools required to support the development and evolution of future generations of Command Control Communications Intelligence and Information Warfare (C3I/IW) systems. It focuses on concepts and approaches defined as part of the Takari programme and considers issues related to tool support for the development of Takari Capability and Technology Demonstrators (CTDs) such as the proposed Experimental C3I Technology Environment (EXC3ITE). A Component-Based Software Engineering (CBSE) lifecycle, which includes both Domain Engineering and Product Engineering, is proposed as a possible development strategy. A tool categorisation framework is defined to help define tool requirements. An initial survey of CBSE tools provides examples of currently available tools which could be considered for each of the tool categories.

Technology was developed to support runtime monitoring i.e., continual validation regarding the dynamic functional and extra-functional properties of component-based systems. Software probes are inserted or wrapped into component ports and actualized connector middleware, to report system events that cross/impact component and connector boundaries. Required an prohibited properties are defined as (potentially complex) patterns over collections of events. The monitoring infrastructure includes recognizers to detect the occurrence or omission of these patters as the components and connectors in response to monitored activities.

The Multi-Instrument Integrated Data Acquisition System (MIIDAS), developed by the NASA Langley Research Center, uses commercial off the shelf (COTS) products, integrated with custom software, to provide a broad range of capabilities at a low cost throughout the system s entire life cycle. MIIDAS combines data acquisition capabilities with online and post-test data reduction computations. COTS products lower purchase and maintenance costs by reducing the level of effort required to meet system requirements. Object-oriented methods are used to enhance modularity, encourage reusability, and to promote adaptability, reducing software development costs. Using only COTS products and custom software supported on multiple platforms reduces the cost of porting the system to other platforms. The post-test data reduction capabilities of MIIDAS have been installed at four aerospace testing facilities at NASA Langley Research Center. The systems installed at these facilities provide a common user interface, reducing the training time required for personnel that work across multiple facilities. The techniques employed by MIIDAS enable NASA to build a system with a lower initial purchase price and reduced sustaining maintenance costs. With MIIDAS, NASA has built a highly flexible next generation data acquisition and reduction system for aerospace test facilities that meets customer expectations.

Book Source: Digital Library of India Item 2015.197656 dc.contributor.author: Avinash dc.date.accessioned: 2015-07-08T11:08:23Z dc.date.available: 2015-07-08T11:08:23Z dc.date.digitalpublicationdate: 2005-10-27 dc.identifier.barcode: 5990010097649 dc.identifier.origpath: /rawdataupload/upload/0097/649 dc.identifier.copyno: 1 dc.identifier.uri: http://www.new.dli.ernet.in/handle/2015/197656 dc.description.scanningcentre: IIIT, Allahabad dc.description.main: 1 dc.description.tagged: 0 dc.description.totalpages: 57 dc.format.mimetype: application/pdf dc.language.iso: English dc.publisher.digitalrepublisher: Digital Library Of India dc.publisher: I I T Kanpur dc.rights: Out_of_copyright dc.source.library: I I T Kanpur dc.subject.classification: Technology dc.subject.classification: Ind And Mgt Engineering dc.title: Patseek A Component Based Image Retrieval Systems

Although distributed systems are widely used nowadays, their implementation and deployment is still a time-consuming, error-prone, and hardly predictive task. In this talk, I will present a methodology for producing automatically efficient and correct-by-construction distributed implementations by starting from a high-level model of the application software in BIP. BIP (Behavior, Interaction, Priority) is a component-based framework with formal semantics that rely on multi-party interactions for synchronizing components and dynamic priorities for scheduling between interactions. Our methodology transforms arbitrary BIP models into Send/Receive BIP models, directly implementable on distributed execution platforms. The transformation consists of (1) breaking the atomicity of actions in atomic components by replacing strong synchronizations with asynchronous Send/Receive interactions; (2) inserting several distributed controllers that coordinate the execution of interactions according to a user-defined assignment of interactions to controllers, and (3) augmenting the model with a distributed algorithm for handling distributed conflicts between controllers. The obtained Send/Receive BIP models are proven observationally equivalent to their corresponding initial models. Hence, all functional properties of the initial high-level model are preserved by construction in the implementation. Moreover, Send/Receive BIP models can be used to automatically derive distributed implementations. Currently, it is possible to generate distributed C++ implementations using (1) TCP sockets for conventional communication, (2) MPI primitives for multi-processor platforms, and (3) POSIX Threads for deployment on multi-core platforms. This method is fully implemented. I will present concrete results obtained under different scenarios (i.e., partitioning of interactions and choice of algorithm for distributed conflict resolution) and case various case studies. ©2011 Microsoft Corporation. All rights reserved.

maintenance