Different Levels Of Abstraction Research Articles

Decoding action concepts at different levels of abstraction – an fMRI MVPA study

Decoding action concepts at different levels of abstraction – an fMRI MVPA study

MAESTRO— Holistic Actor-Oriented Modeling of Nonfunctional Properties and Firmware Behavior for MPSoCs

Modeling and evaluating nonfunctional properties such as performance, power, and reliability of embedded systems are tasks of utmost importance. In this article, we introduce M AESTRO , a methodology for the modeling and evaluation of nonfunctional properties and embedded firmware of MPSoC architecture components at the Electronic System Level (ESL). In contrast to existing design flows that provide predefined performance models, M AESTRO defines a flexible approach that allows to define virtual prototypes that can be easily customized and extended to evaluate multiple nonfunctional properties of interest at different levels of abstraction. In M AESTRO , a design is composed purely from actor-oriented models. This enables typical ESL features such as automatic design space exploration and synthesizability of HW and SW components, typically missing in very general design flows. Unique to M AESTRO is the separation and coordination of the interaction between application functionality, firmware, and performance models for the evaluation of nonfunctional properties, and their complex interactions within a single Model-of-Computation (MoC). The main advantages of M AESTRO are: (I) Extensible modeling of interdependent nonfunctional properties of heterogeneous MPSoC components; (II) high flexibility to investigate the appropriate trade-off between modeling effort and accuracy of nonfunctional property evaluators; (III) a holistic approach for modeling application functionality as well as firmware affecting the evaluation of nonfunctional properties. Regarding (II), we present a mobile baseband processor platform use-case, executing a GSM paging application. To demonstrate (I) and (III), we present the modeling of a complex ESL processor virtual prototype, running a soft real-time application and equipped with both a power and reliability manager.

Up and out

Systems are naturally constructed in hierarchies in which design choices made at higher levels of abstraction ``flow down'' to requirements on system components at lower levels of abstraction. Thus, whether an aspect of the system is a design choice or a requirement depends largely on one's vantage point within the hierarchy of system components. Furthermore, systems are often constructed middle-out rather than top-down; compatibility with existing systems and architectures, or availability of specific components influences high-level requirements. We believe that requirements and architectural design should be more closely aligned: that requirements models must account for hierarchical system construction, and that architectural design notations must better support specification of requirements for system components. In this presentation, I describe tools supporting iterative development of architecture and verification based on software models. We represent the hierarchical composition of the system in the Architecture Analysis & Design Language (AADL), and use an extension to the AADL language to describe requirements at different levels of abstraction for compositional verification. To describe and verify component-level behavior, we use Simulink and Stateflow and multiple analysis tools.

Compositional verification of a medical device system

Complex systems are by necessity hierarchically organized. Decomposition into subsystems allows for intellectual control, as well as enabling different subsystems to be created by distinct teams. This decomposition affects both requirements and architecture. The architecture describes the structure and this affects how requirements ``flow down'' to each subsystem. Moreover, discoveries in the design process may affect the requirements. Demonstrating that a complex system satisfies its requirements when the subsystems are composed is a challenging problem. In this paper, we present a medical device case example where we apply an iterative approach to architecture and verification based on software architectural models. We represent the hierarchical composition of the system in the Architecture Analysis and Design Language (AADL), and use an extension to the AADL language to describe the requirements at different levels of abstraction for compositional verification. The component-level behavior for the model is described in Simulink/Stateflow. We assemble proofs of system level properties by using the Simulink Design Verifier to establish component-level properties and an open-source plug-in for the OSATE AADL environment to perform the compositional verification of the architecture. This combination of verification tools allows us to iteratively explore design and verification of detailed behavioral models, and to scale formal analysis to large software systems.

Reusing Test-Cases on Different Levels of Abstraction in a Model Based Development Tool

Seamless model based development aims to use models during all phases of the development process of a system. During the development process in a component-based approach, components of a system are described at qualitatively differing abstraction levels: during requirements engineering component models are rather abstract high-level and underspecified, while during implementation the component models are rather concrete and fully specified in order to enable code generation. An important issue that arises is assuring that the concrete models correspond to abstract models. In this paper, we propose a method to assure that concrete models for system components refine more abstract models for the same components. In particular we advocate a framework for reusing testcases at different abstraction levels. Our approach, even if it cannot completely prove the refinement, can be used to ensure confidence in the development process. In particular we are targeting the refinement of requirements which are represented as very abstract models. Besides a formal model of our approach, we discuss our experiences with the development of an Adaptive Cruise Control (ACC) system in a model driven development process. This uses extensions which we implemented for our model-based development tool and which are briefly presented in this paper.

Phonological similarity in multi-word units

Abstract In this paper, I investigate the phonological similarity of different elements of the phonological pole of multi-word units. I discuss two case studies on slightly different levels of abstractness. The first case study investigates lexically fully-specified V-NPDirObj idioms such as kick the bucket and lose one's cool; the idioms investigated are taken from the Collins Cobuild Dictionary of Idioms (Harper Collins, 2002). The second case study investigates the lexically less specified way-construction, which is exemplified by He fought his way through the crowd (cf. Goldberg, Constructions: A Construction Grammar approach to argument structure, The University of Chicago Press, 1995: Ch. 9), on the basis of data from the British National Corpus 1.0. I show that both patterns exhibit a strong phonological within-pole relation, namely a strong preference for having their slots filled with phonologically similar elements, where phonological similarity is manifested in alliteration patterns. These preferences are statistically significant when compared to chance-level expectations derived both from the corpora and from the CELEX database (Baayen et al., The CELEX Lexical Database (CD-ROM), University of Pennsylvania, 1995) and are explained on the basis of Langacker's concept of syntactic and phonological constituents as well as current exemplar-/usage-based approaches.

Formalizing a hierarchical file system

Abstract An abstract file system is defined here as a partial function from (absolute) paths to data. Such a file system determines the set of valid paths. It allows the file system to be read and written at a valid path, and it allows the system to be modified by the Unix operations for creation, removal, and moving of files and directories. We present abstract definitions (axioms) for these operations. This specification is refined towards a pointer implementation. The challenge is to have a natural abstraction function from the implementation to the specification, to define operations on the concrete store that behave exactly in the same way as the corresponding functions on the abstract store, and to prove these facts. To mitigate the problems attached to partial functions, we do this in two steps: first a refinement towards a pointer implementation with total functions, followed by one that allows partial functions. These two refinements are proved correct by means of a number of invariants. Indeed, the insights gained consist, on the one hand, of the invariants of the pointer implementation that are needed for the refinement functions, and on the other hand of the precise enabling conditions of the operations on the different levels of abstraction. Each of the three specification levels is enriched with a permission system for reading, writing, or executing, and the refinement relations between these permission systems are explored. Files and directories are distinguished from the outset, but this rarely affects our part of the specifications. All results have been verified with the proof assistant PVS, in particular, that the invariants are preserved by the operations, and that, where the invariants hold, the operations commute with the refinement functions.

Discrete scale axis representations for 3D geometry

This paper addresses the fundamental problem of computing stable medial representations of 3D shapes. We propose a spatially adaptive classification of geometric features that yields a robust algorithm for generating medial representations at different levels of abstraction. The recently introduced continuous scale axis transform serves as the mathematical foundation of our algorithm. We show how geometric and topological properties of the continuous setting carry over to discrete shape representations. Our method combines scaling operations of medial balls for geometric simplification with filtrations of the medial axis and provably good conversion steps to and from union of balls, to enable efficient processing of a wide variety shape representations including polygon meshes, 3D images, implicit surfaces, and point clouds. We demonstrate the robustness and versatility of our algorithm with an extensive validation on hundreds of shapes including complex geometries consisting of millions of triangles.

Sensors Data-Stream Processing Middleware based on Multi-Agent Model

The goal of this study is to propose an architecture for an intelligent sensor data processing middleware. In order to fulfill the ambient assisted living data processing requirements we design a flexible and scalable architecture based on multi-agent model. This architecture allows acquisition, interpretation and aggregation of sensor data-streams. Our system is able to process different sensor data-streams, to adapt to different levels of abstraction, to define different data-processing workflows. An extended operators over data stream language is used to define workflows. Different types of agents (simple sensor agent, logic sensor agent, virtual sensor agent etc) are defined. The designed system is a domain independent multi-agent system which can be instantiated for particular AmI problems. The middleware architecture will use a healthcare system for validation.

The direction of hemispheric asymmetries for object categorization at different levels of abstraction depends on the task

In this study hemispheric asymmetries for categorizing objects at the basic versus subordinate level of abstraction were investigated. As predictions derived from different theoretical approaches are contradictory and experimental evidence is inconclusive in this regard, we conducted two categorization experiments, where we contrasted two experimental paradigms. In the first experiment, subjects had to verify whether a word and a laterally presented picture matched or not. In the second experiment, subjects had to identify laterally presented pictures of animals either at the basic or subordinate level by pressing a corresponding response key. Whereas the first experiment revealed an advantage of the left hemisphere (LH) for categorizing objects at the basic level and of the right hemisphere (RH) for categorizing at the subordinate level, just the opposite brain asymmetry was found in the second experiment. As the stimuli were identical in both experiments, hemispheric asymmetries seem to be strongly task dependent.

Automated formal specification generation and refinement from requirement documents

Abstract The automatic generation of formal specifications from requirements suppresses the complexity of formal models manual creation and reveals the immediate benefits of its usage, such as the possibility to carry out refinements, and property verification, which contributes to project cost reduction and quality improvement. This paper proposes a Controlled Natural Language (CNL), a subset of English, used to write use case specifications according to a template. From these use cases a complete strategy and tools enable the generation of process algebraic formal models in the CSP notation. We define templates that represent requirements at different levels of abstraction, capturing different views of the system behavior. Moreover, a refinement notion is defined to connect the generated CSP models through an event mapping relation between abstract and concrete models. This notion is further applied to detail use case specifications and to automate its execution.

Artifacts Recovery at Different Levels of Abstractions

Artifacts Recovery at Different Levels of Abstractions

Visualization of Spatial Data Structures on Different Levels of Abstraction

Spatial data structures are used to manipulate location data. The visualization of such structures faces many challenges that are not relevant in the visualization of one-dimensional data. The visualized data can be represented using several different types of visual metaphors. These metaphors can be divided into several different levels of abstraction depending on the purpose of the visualization. This paper proposes a division of data structure visualization into four levels of abstraction, and shows how these abstractions can be taken into account in the visualization of spatial data structures.

Distributed Computing: Principles and Applications

Distributed Computing: Principles and Applications M. L. Liu, First Edition, Addison Wesley Publishing Company, Boston, MA, 2003 448 pages, $89.40 Language: English ISBN: 0201796449 Distributed computing, one of the most highly implemented computer theories, is a computing methodology in which tasks are collaborated among collections of interconnected, independent computers. The World Wide Web, Remote Procedure Call (RPC), Java Remote Method Invocation (Java RMI) and collaborative application such as mobile agent systems are some common examples of distributed computing. With the recent growth of net-centric applications, it is essential to equip undergraduate students with the necessary knowledge to attend to and fulfill such demands. As the author suggested in the preface, the purpose of Distributed Computing: Principles and Applications is to introduce to undergraduate students the different paradigms of distributed computing, as well as to provide programming examples to reinforce topics within each paradigm. The book is organized into two key parts: chapter 1 through chapter 3 educates readers about the fundamental concepts and the various paradigms of distributed computing; the remaining 9 chapters further explains each paradigm in greater detail and promotes clarification through code examples. At the end of each chapter, the author supplies a summary of the significant subjects as well as a set of exercise problems. Relevant references are also provided to direct interested readers to further resources. In the first part of the book (chapter 1, 2 and 3), the author first defines distributed computing and then presents the principles of distributed computing from different perspectives including operating system, network and software engineering. To ensure that readers wholly comprehend the communication mechanism behind distributed computing, the author discusses interprocess communications thoroughly. The first part ends with a classification of various paradigms of distributed applications with respect to their level of abstraction. The trade-offs among the different levels of abstractions are also discussed to educate readers on some of the issues that need to be considered when choosing an appropriate paradigm. The second part of the book (chapter 4s through 12) provides in-depth discussions of each paradigm. Examples and sample codes are used to help illustrate the communication mechanism of each paradigm in each chapter. Chapter 4 demonstrates distributed computing using the socket API, the lowest level of abstraction, and illustrates this with both datagram and stream-mode sockets of Java socket APIs. Built on top of the socket API, the client-server paradigm is the most commonly implemented approach in networked environments. The Internet is one such example; and chapter 9 and 11 further elaborates on the different applications that exist on the Internet. Chapter 6 discusses group communication involving multicast mechanisms. The author then focuses on the distributed objects in chapter 7, 8, and 10, where she covers Remote Procedure Call (RPC), Remote Method Invocation (RMI), Common Object Request Broker Architecture (COBRA) and Java Interface Definition Language (IDL). Finally, the book ends with an overview of the current advanced distributed computing areas including message queue system, mobile agents, network services, object spaces and collaborative computing. Overall, this book is more informative than practical, in that it attempts to cover many significant distributed computing methodologies without thoroughly explaining everything to ensure the concepts can be grasped by undergraduate students. Although there are code examples in most chapters, they are intended for illustration purposes and lack challenge. Exercises in the end of each chapter are reasonable, but could include more advanced problems to encourage students to seek additional relevant knowledge beyond the book. References are adequate and can be improved with more recent studies. It may also be good to introduce well known distributed computing projects such as the BOINC to students. Despite some grammar imperfection, the book itself does provide excellent introduction materials to students with little or none knowledge of distributed computing. Yung-Chuan Lee, Department of Computer Science Southern Illinois University Carbondale, IL 62901, USA

A Coloured Petri Net Approach to Formalising and Analysing the Resource Reservation Protocol


 
 
 The goal of the Resource Reservation Protocol (RSVP) is to support the provision of the Quality of Service required for emerging Internet applications (such as video conferencing) that require a level of performance not guaranteed by the Internet. RSVP attempts to provide performance guarantees by establishing resource reservations (such as the number of buffers and bandwidth allocation) within routers and host computers of the Internet. Currently, Internet protocols are not formally specified when they are developed. Instead they are described in a narrative way in documents called Request for Comments(RFCs). This is the case for RSVP. To increase confidence in RSVP we have formalised and analysed its narrative specification using Coloured Petri Nets (CPNs). This paper demonstrates how CPNs can be used for modelling and analysing RSVP. Among the several beneficial features of CPNs are: graphical facilities for specification; support for different levels of abstraction; hierarchical structuring mechanisms; and verification and validation methods, such as querying the state space to investigate properties, and language equivalence to check the consistency of different levels of abstraction. Coloured Petri Nets are supported by a number of computer tools including Design/CPN. Design/CPN supports the construction and maintenance of CPN models and their simulation and analysis using state spaces. These facilities allow us to create a model that provides a clear, unambiguous and precise definition of RSVP, and to analyse the protocol for functional correctness. The paper concentrates on the approach and the tools used in this investigation.
 
 

Understanding how patients form beliefs about pharmacists' trustworthiness using a model of belief processing.

To determine what information people use in forming beliefs about pharmacists' trustworthiness and to determine whether these pieces of information can be categorized using elements of a model of belief processing. Participants in two focus groups were asked about the trustworthiness of pharmacists in one dispensing scenario and two pharmaceutical care scenarios. Transcripts were analyzed, and each piece of information provided was coded as an evidence statement or a claim, according to a model of belief processing. University campus. University staff and students. Information used to form beliefs about pharmacists' trustworthiness and classification of the information using constructs from the model of belief processing. Coders identified 92 evidence statements and 19 claims. An evaluation of the data across the scenarios using predetermined criteria showed 20 evidence statements and 11 claims to be the most salient pieces of information used to form beliefs about pharmacists' trustworthiness. In considering the pharmaceutical care scenarios, participants focused more on communication and interpersonal skills when forming a trustworthiness belief. The information could be categorized as evidence statements or claims, which are parts of arguments as described by a model of belief processing. The study participants used the pharmacists' credentials, communication skills, personableness, and appearance to form trustworthiness beliefs. Overall, they wanted pharmacists to be honest, knowledgeable, and caring. Variables used to form trustworthiness beliefs represent different levels of abstraction that can be detected and coded using a model of belief processing.

Chart-based techniques for representing designs at different levels of abstraction

One of the acceptable sequences of the working stages of the design process contains: (a) specifications, (b) conceptual design, (c) embodiment design, and (d) detailed design as its working stages. Following the principle of deployment as used in quality function deployment, it can be said that specifications deploy customer requirements, conceptual design deploys specifications and embodiment design deploys conceptual design. Based on this deployment principle it is possible to establish three charts namely: (a) specification chart, (b) conceptual design chart, and (c) embodiment design chart to represent the designs at different levels of abstraction. The paper describes how these charts are constructed and used to store designs. It also shows how the charts can be developed to represent the design of a portable belt conveyor at different stages.

Coupling Use Cases and Class Models as a Means for Validation and Verification of Requirements Specifications

In many applications, especially from the business domain, the requirements specification mainly deals with use cases and class models. Unfortunately, these models are based on different modelling techniques and aim at different levels of abstraction, such that serious consistency and completeness problems are induced. To overcome these deficiencies, we refine activity graphs to meet the needs for a suitable modelling element for use case behaviour. The refinement in particular supports the proper coupling of use cases via activity graphs and the class model. The granularity and semantics of our approach allow for a seamless, traceable transition of use cases to the class model and for the verification of the class model against the use case model. The validation of the use case model and parts of the class model is supported as well. Experience from several applications has shown that the investment in specification, validation and verification not only pays off during system and acceptance testing but also significantly improves the quality of the final product.

Expert-novice knowledge of computer programming at different levels of abstraction.

Computer programming knowledge can be classified into five levels of abstraction: objective, conceptual, functional, logical, and physical. An experiment was carried out to determine whether the mastering of knowledge at different levels of abstraction changed with the level of skill. Ten experts and ten novices in C computer programming participated in the experiment. The subjects' knowledge at the five levels of abstraction was tested through 20 multiple-choice questions. The experimental results indicated that knowledge differences between experts and novices at an abstract level or a concrete level depended on what abstract or concrete knowledge was implied. Experts had better abstract knowledge than novices at the conceptual and functional levels but not at the objective level. Experts had better concrete knowledge than novices at the physical level but not at the logical level. The classification of computer programming knowledge in levels of abstraction and the experimental results helped in clarifying a general finding from previous studies that experts had better abstract knowledge than novices.

Automatizing Parametric Reasoning on Distributed Concurrent Systems

Abstract There can be different views of a concurrent distributed system, depending on who observes it. The final user may just want to know how the system behaves in terms of its possible sequences of actions, while the designer may want to know what are the sequential components of a system or how are they distributed in space. In other words, there is not a widely accepted single semantic model for concurrent systems. This paper describes a parametric verification tool for process description languages. It performs a symbolic execution of processes at different levels of abstraction and verifies deadlock and reachability properties. The tool also provides facilities to check behavioural equivalences. In addition to the classical interleaving semantics, truly concurrent approaches based on the notion of causality and locality are considered. This allows us to compare the expressive power of different models within the same environment. In this respect, we have verified many of the examples given in the literature using our tool.