DOI: 10.3897/jucs.97822

Authors: Herminia Beatriz Parra de Gallo, Marcela Vegetti

Abstract: This paper shows the research conducted to respond to a continuous requirement of justice regarding the application of scientifically supported forensic tools. Considering ontological engineering as the appropriate framework to respond to this requirement, the article presents OntoFoCE (Spanish abbreviation for Ontology for Electronic Mail Forensics), a specific ontology for the forensic analysis of emails. The purpose of this ontology is to help the computer expert in the validation of an email presented as judicial evidence. OntoFoCE is the fundamental component of the ObE Forensics (Ontology-based Email Forensics) tool. Although there are numerous forensic tools to analyze emails, the originality of the one proposed here lies in the implementation of semantic technologies to represent the traceability of the email transmission process. From that point on, it is possible to provide answers to the items of digital evidence subject to the expert examination. These answers make it possible to support these evidence items in the forensic analysis of an email and to guarantee the gathering of scientifically and technically accepted results that are valid for justice. Thus, the research question that is tried to be answered is: Is it possible to apply ontological engineering as a scientific support to design and develop a forensic tool that allows automatic answers to the evidence items subject to the expert examination in the forensic analysis of emails?

HTML

XML

PDF

DOI: 10.3217/jucs-023-09-0808

Authors: Mario Bravetti

Abstract: Web Operating Systems can be seen as an extension of traditional Operating Systems where the addresses used to manage files and execute programs (via the basic load/execution mechanism) are extended from local filesystem path-names to URLs. A first consequence is that, similarly as for traditional web technologies, executing a program at a given URL can be done in two modalities: either the execution is performed client-side at the invoking machine (and relative URL addressing in the executed program set to refer to the invoked URL) or it is performed server-side at the machine addressed by the invoked URL (as, e.g., for a web service). Moreover in this context, user identification for access to programs and files and workow-based composition of service programs is naturally based on token/session-like mechanisms. We propose a middleware based on client-server protocols and on a set primitives, for managing files/resources and executing programs (in the form of client-side/server-side components/services) in Web Operating Systems, based on an extension of the REST architecture. In order to provide an unambiguous specification, we formally define the semantics of such middleware by first introducing a process algebra for standard REST and then extending it to the whole middleware.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0063

Authors: Henning Basold, Herman Geuvers, Niels Van Der Weide

Abstract: We propose general rules for higher inductive types with non-dependent and dependent elimination rules. These can be used to give a formal treatment of data types with laws as has been discussed by David Turner in his earliest papers on Miranda [Turner(1985)]. The non-dependent elimination scheme is particularly useful for defining functions by recursion and pattern matching, while the dependent elimination scheme gives an induction proof principle. We have rules for non-recursive higher inductive types, like the integers, but also for recursive higher inductive types like the truncation. In the present paper we only allow path constructors (so there are no higher path constructors), which is sufficient for treating various interesting examples from functional programming, as we will briefly show in the paper: arithmetic modulo, integers and finite sets.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0005

Authors: Philip Wadler

Abstract: The data abstraction mechanism of Miranda may be adapted to a dynamically typed programming language by applying ideas from gradual typing.

HTML

XML

PDF

DOI: 10.3217/jucs-020-09-1174

Authors: Antonina Danylenko, Jonas Lundberg, Welf Löwe

Abstract: Classification is a constitutive part in many different fields of Computer Science. There exist several approaches that capture and manipulate classification information in order to construct a specific classification model. These approaches are oftentightly coupled to certain learning strategies, special data structures for capturing the models, and to how common problems, e.g. fragmentation, replication and model over-fitting, are addressed. In order to unify these different classification approaches, we define a Decision Algebrawhich defines models for classification as higher order decision functions abstracting from their implementations using decision trees (or similar), decision rules, decisiontables, etc. Decision Algebra defines operations for learning, applying, storing, merging, approximating, and manipulating models for classification, along with some generalalgebraic laws regardless of the implementation used. The Decision Algebra abstraction has several advantages. First, several useful DecisionAlgebra operations (e.g., learning and deciding) can be derived based on the implementation of a few core operations (including merging and approximating). Second,applications using classification can be defined regardless of the different approaches.Third, certain properties of Decision Algebra operations can be proved regardless of the actual implementation. For instance, we show that the merger of a series of probablyaccurate decision functions is even more accurate, which can be exploited for efficientand general online learning. As a proof of the Decision Algebra concept, we compare decision trees with decisiongraphs, an efficient implementation of the Decision Algebra core operations, which cap-ture classification models in a non-redundant way. Compared to classical decision tree implementations, decision graphs are 20% faster in learning and classification withoutaccuracy loss and reduce memory consumption by 44%. This is the result of experiments on a number of standard benchmark data sets comparing accuracy, access time, and sizeof decision graphs and trees as constructed by the standard C4.5 algorithm. Finally, in order to test our hypothesis about increased accuracy when merging decisionfunctions, we merged a series of decision graphs constructed over the data sets. The result shows that on each step the accuracy of the merged decision graph increases withthe final accuracy growth of up to 16%.

HTML

XML

PDF

DOI: 10.3217/jucs-019-03-0353

Authors: Angels Rius, Jordi Conesa, Elena Garcia-Barriocanal, Miguel-Ángel Sicilia

Abstract: Beyond the kind of processes dealt with the IMS LD specification, there are other kinds of processes, which are repeated periodically in learning environments that have not already been described yet due to the lack of mechanisms to describe them effectively. Inspired by the standard specification of language processes in the business area and taking into account the patterns philosophy used in the software engineering field, we propose an open framework to formally describe generic processes that usually occurs in the learning environments as patterns of educational settings. The main contribution of this paper is an extensible ontology-based framework to specify processes in learning environments. This framework has been created with the aim of improving the reusability of its formal specifications independently of the educational institutions where the processes occur and the learning platforms that support such processes. As a result of this work we have created a graphical notation for specifying such kind of processes easily and a CASE tool to facilitate its representation and the population of the ontological framework. In a future this framework could be extended to take more advantages: adapting the specifications of patterns to different educational institutions, using an implementation profile to achieve implementation descriptions or other standards to provide other output formats.

HTML

XML

PDF

DOI: 10.3217/jucs-018-17-2364

Authors: Juan Vara, Vasilios Andrikopoulos, Michael Papazoglou, Esperanza Marcos

Abstract: In the field of Service-Oriented Architecture (SOA) evolution is a key issue given the non-trivial nature of updating widely distributed and heterogeneous systems. With this in mind, in this work we used some of the technologies developed in the context of the Eclipse Modeling Framework (EMF) to provide a proof of concept of the possible synergy between Model-Driven Engineering (MDE) and Service Orientation. In particular, we present a DSL toolkit for modeling the structural part of Abstract Service Descriptions (ASDs) and the reasoning mechanism that assesses whether two versions of a service are compatible with respect to its consumers.

HTML

XML

PDF

DOI: 10.3217/jucs-016-20-2904

Authors: Alessander Benevides, Giancarlo Guizzardi, Bernardo Ferreira Bastos Braga, Joao Paulo Andrade Almeida

Abstract: Assessing the quality of conceptual models is key to ensure that conceptual models can be used effectively as a basis for understanding, agreement and construction of information systems. This paper proposes an approach to assess conceptual models defined in OntoUML by transforming these models into specifications in the logic-based language Alloy. These Alloy specifications include the modal axioms of the theory underlying OntoUML, allowing us to validate the modal meta-properties representing ontological commitments of the OntoUML types and relations.

HTML

XML

PDF

DOI: 10.3217/jucs-015-14-2836

Authors: Alberto Encina, Luis Llana, Fernando Rubio

Abstract: Due to the absence of side effects, reasoning about functional programsis simpler than reasoning about their imperative counterparts. However, because of the absence of practical debuggers, finding bugs in lazy functional languages has beenmore complex until quite recently. One of the easiest to use Haskell debuggers is Hood. Its behavior is based on the concept of observation of intermediate data structures.However, although using Hood can be simple when observing some structures, it is known that it can be hard to understand how it works when dealing with complexsituations. In fact, the author of Hood recognizes that it is necessary to formalize its behavior to explain better what should be expected, and also to allow to check whetherthe different implementations work properly. In this paper, we formalize the behavior of the Hood debugger by extending Sestoft'snatural semantics. Moreover, we also show how to derive an abstract machine including such debugging information. By doing so, we do not only provide a formal foundation,but we also provide an alternative method to implement debuggers. In fact, we have already made a prototype of the abstract machine presented in this paper.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3608

Authors: Mikai Yang, Greg Michaelson, Rob Pooley

Abstract: The abstract syntax and static semantics of UML, the widely-used generalpurpose graphical modeling language, have been standardized in a four-layer metamodeling framework. However UML's dynamic semantics, such as UML Precise Action Semantics and the behaviors like activities, interactions and state machines, are only standardized in a natural language-English. It is commonly argued that such informal description inevitably involves ambiguities and lacks rigorousness, precluding the early simulation and reasoning about a UML system design. Here we select Action Semantics (AS) as the vehicle to formalize UML. AS is a mature semantics description framework which has advantages of intelligibility, modularity and practicability. In our approach, we formalize UML indirectly by formalizing its textual correspondent-an extended Action Language, which plays a key role as the interface between UML and its action semantics.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3592

Authors: Fabio Tirelo, Roberto Bigonha, Joâo Saraiva

Abstract: Denotational semantics is a powerful technique to formally define programming languages. However, language constructs are not always orthogonal, so many semantic equations in a definition may have to be aware of unrelated constructs semantics. Current approaches for modularity in this formalism do not address this problem, providing, for this reason, tangled semantic definitions. This paper proposes an incremental approach for denotational semantic specifications, in which each step can either add new features or adapt existing equations, by means of a formal language based on function transformation and aspect weaving.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3534

Authors: Fernando Rubbo, Rodrigo Machado, Álvaro Moreira, Leila Ribeiro, Daltro Nunes

Abstract: The latest versions of AspectJ, the most popular aspect-oriented extension for Java, must cope with the complex changes that occurred in the Java type system, specially with those that introduced type parameters for classes and methods. In this work we study the influence of raw types, i.e. parameterless instantiations of class types, over the semantics of an AspectJ-like language. As a result, we define an operational semantics and a type system for a calculus, named Raw Aspect Featherweight Generic Java (Raw-AFGJ), that represents a minimal aspect-oriented extension of Raw Featherweight Generic Java. Through our calculus it is possible to achieve a better understanding of several subtleties of aspect weaving with the restrictions imposed by raw types support in the type system.

HTML

XML

PDF

DOI: 10.3217/jucs-014-12-1929

Authors: Gerhard Schellhorn

Abstract: This paper gives a definition of ASM refinement suitable for the verification that a protocol implements atomic transactions. We used this definition as the basis of the formal verification of the refinements of the Mondex case study with the interactive theorem prover KIV. The refinement definition we give differs from the one we gave in earlier work which preserves partial and total correctness assertions of ASM runs. The reason is that the main goal of the refinement of the Mondex protocol is to preserve a security invariant, while total correctness is not preserved. To preserve invariants, the definition of generalized forward simulation is limited to the use of "small" diagrams, which contain of a single protocol step. We show a technique that allows to use the natural "big" diagrams that consist of an atomic action being refined by a full protocol run.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0874

Authors: Carlos Camarão, Cristiano Vasconcellos, Lucília Figueiredo, João Nicola

Abstract: The type system of Haskell and some related systems are based on an open world approach for overloading. In an open world, the principal type of each overloaded symbol must be explicitly annotated (in Haskell, annotations occur in type class declarations) and a definition of an overloaded symbol is required to exist only when overloading is resolved. In a closed world, on the other hand, each principal type is determined according to the types of definitions that exist in the relevant context and, furthermore, overloading resolution for an expression considers only the context of the definition of its constituent symbols. In this paper we formally characterize open and closed worlds, and discuss their relative advantages. We present a type system that supports both approaches together, and compare the defined system with Haskell type classes extended with multi-parameter type classes and functional dependencies. We show in particular that functional dependencies are not necessary in order to support multi-parameter type classes, and present an alternative route.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1521

Authors: David Escrig, Carlos Rodríguez

Abstract: Bisimulation can be defined in a simple way using coinductive methods, and has rather pleasant properties. Ready similarity was proposed by Meyer et al. as a way to weakening the bisimulation equivalence thus getting a semantics defined in a similar way, but supported for more reasonable (weaker) observational properties. Global bisimulations were introduced by Frutos et al. in order to study different variants of non-determinism getting, in particular, a semantics under which the internal choice operator becomes associative. Global bisimulations are defined as plain bisimulations but allowing the use of new moves, called global transitions, that can change the processes not only locally in its head, but anywhere. Now we are continuing the study of global bisimulation but focusing on the way different semantics can be characterised as global bisimulation semantics. In particular, we have studied ready similarity, on the one hand because it was proposed as the strongest reasonable semantics weaker than bisimulation; on the other hand, because ready similarity was not directly defined as an equivalence relation but as the nucleus of an order relation, and this open the question whether it is also possible to define it as a symmetric bisimulation-like semantics. We have got a simple and elegant characterisation of ready similarity as a global bisimulation semantics, that provides a direct symmetric characterisation of it as an equivalence relation, without using any order as intermediate concept. Besides, we have found that it is not necessary to start from a simulation based semantics to get an equivalent global bisimulation. What has proved to be very useful is the axiomatic characterisation of the semantics. Following these ideas we have got also global bisimulation for several semantics, including refusals and traces. That provides a general framework that allows to relate both intensional and extensional semantics.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0922

Authors: Paula Ribeiro, Marco Barbosa, Luís Barbosa

Abstract: Emerging interaction paradigms, such as service-oriented computing, and new technological challenges, such as exogenous component coordination, suggest new roles and application areas for process algebras. This, however, entails the need for more generic and adaptable approaches to their design. For example, some applications may require similar programming constructs coexisting with different interaction disciplines. In such a context, this paper pursues a research programme on a coinductive rephrasal of classic process algebra, proposing a clear separation between structural aspects and interaction disciplines. A particular emphasis is put on the study of interruption combinators defined by natural co-recursion. The paper also illustrates the verification of their properties in an equational and pointfree reasoning style as well as their direct encoding in Haskell.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0849

Authors: Markus Schordan

Abstract: Design patterns have been developed to cope with the vast space of possible different designs within object-oriented systems. One of those classic patterns is the Visitor Pattern, used for representing an operation to be performed on the elements of an object structure. In general, the order in which the objects are visited is crucial. We present a mapping from the Visitor Pattern to a context free grammar that defines the set of all such visit sequences, a given Visitor can perform. The language defined by this grammar is the language of the Visitor Design Pattern and the mapping encodes knowledge about the class hierarchy and the implementation of the accept methods of a Visitor Design Pattern. It is general enough to model complications that occur when traversing arbitrary object structures, and also properly represents cases such as lack of a common base class, multiple inheritance, and inheritance from concrete classes. Due to its particular design, the grammar can also be used as precise documentation for a Visitor Design Pattern.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1327

Authors: Marcelo Amorim, Grigore Rosu

Abstract: This work describes the formal semantics of Scheme 3 as an equational theory in the Maude rewriting system. The semantics is based on continuations and is highly modular. We briefly investigate the relationship between our methodology for defining programming languages and other semantic formalisms. We conclude by showing some performance results of the interpreter obtained for free from the executable specification.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1311

Authors: Tarmo Uustalu, Tarmo Vene

Abstract: We propose a novel discipline for programming stream functions and for the semantic description of stream manipulation languages based on the observation that both general and causal stream functions can be characterized as coKleisli arrows of comonads. This seems to be a promising application for the old, but very little exploited idea that if monads abstract notions of computation of a value, comonads ought to be useable as an abstraction of notions of value in a context. We also show that causal partial-stream functions can be described in terms of a combination of a comonad and a monad.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1215

Authors: Cheikh Ba, Marcos Carrero, Mirian Ferrari, Martin Musicante

Abstract: Recent proposals in the domain of interface description languages for web services stress the importance of specifying the dynamic, behavioral aspects of the services. The goal of this paper is to introduce a new interface description language, called PEWS, that uses predicate path expressions to define web service behaviours. Our proposal represents a simple but expressive way to describe order and conditional constraints over web service operations. PEWS aims to be used not only to the specification of simple web services but also to be a tool for describing service composition. In this paper, we use the Action Semantics framework to present the syntax and semantics of the most significant parts of PEWS and we introduce XPEWS, the XML-based version of PEWS used to publish service behaviours for future searches and composition. The definition of XPEWS is done by giving the XML Schema that defines the syntax of XPEWS programs.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1117

Authors: Peter Mosses

Abstract: Most approaches to formal semantics are based on the assumption that all the constructs of a language are defined together. The details of the definition of each construct can (and usually do) depend on which other constructs are included in the given language. This limits reuse of definitions of common constructs. With the more constructive approach proposed here, the semantics of each basic abstract programming construct is defined separately and independently. The semantics of a full language is obtained by translating its constructs into the basic abstract constructs, whose definitions are thus reused verbatim. The frameworks of Modular SOS and Action Semantics can both be used in conjunction with the proposed approach. Some illustrations are given.

HTML

XML

PDF

DOI: 10.3217/jucs-011-05-0712

Authors: Michael Butler, Carla Ferreira, Muan Ng

Abstract: We describe the StAC language which can be used to specify the orchestration of activities in long running business transactions. Long running business transactions use compensation to cope with exceptions. StAC supports sequential and parallel behaviour as well as exception and compensation handling. We also show how the B notation may be combined with StAC to specify the data aspects of transactions. The combination of StAC and B provides a rich formal notation which allows for succinct and precise specification of business transactions. BPEL is an industry standard language for specifying business transactions and includes compensation constructs. We show how a substantial subset of BPEL can be mapped to StAC thus demonstrating the expressiveness of StAC and providing a formal semantics for BPEL.

HTML

XML

PDF

DOI: 10.3217/jucs-010-09-1272

Authors: James Power, David Sinclair

Abstract: In this paper we develop a formal specification of aspects of the Forth programming language. We describe the operation of the Forth compiler as it translates XSForth control words, dealing in particular with the interpretation of immediate words during compilation. Our goal here is to provide a basis for the study of safety properties of embedded systems, many of which are constructed using Forth or Forth-like languages. To this end we construct a model of the Forth compiler in the -calculus, and have simulated its execution by animating this model using the Pict programming language.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0808

Authors: Marco Barbosa, Luís Barbosa

Abstract: The basic motivation of component based development is to replace conventional programming by the composition of reusable off-the-shelf units, externally coordinated through a network of connecting devices, to achieve a common goal. This paper introduces a new relational model for software connectors and discusses some preliminary work on its implementation in HASKELL. The proposed model adopts a coordination point of view in order to deal with components' temporal and spatial decoupling and, therefore, to provide support for looser levels of inter-component dependency and effective external control.

HTML

XML

PDF

DOI: 10.3217/jucs-009-11-1261

Authors: Doron Drusinsky, Man-Tak Shing

Abstract: Run-time monitoring of temporal properties and assertions is used for testing and as a component of execution-based model checking techniques. Traditional run-time monitoring however, is limited to observing sequences of pure Boolean propositions. This paper describes tools for observing temporal properties over time series, namely, sequences of propositions with constraints on data value changes over time. Using such Temporal Logic with time Series (TLS), it is possible to monitor important properties such as stability, monotonicity, temporal average and sum values, and temporal min/max values. The specification and monitoring of linear time temporal logic with real-time and time series constraints are supported by the Temporal Rover and the DBRover, which are in-process and remote run-time monitoring tools. The novel TLS extension described in this paper is based on practical experience and feedback provided by NASA engineers after using the DBRover to verify flight code. The paper also presents a novel hybrid approach to verify timing properties in rapid system prototyping that combines the traditional schedulability analysis of the design and the monitoring of timing constraint satisfaction during prototype execution based on a time-series temporal logic. The effectiveness of the approach is demonstrated with a prototype of the fish farm control system software.

HTML

XML

PDF

DOI: 10.3217/jucs-009-09-1030

Authors: Kazuko Takahashi

Abstract: We discuss how a property of some region is propagated to other regions. We propose a system called SRCC that enables the integration of spatial and semantic data. SRCC can represent the relative positions of regions, properties that hold in some regions, semantic relation between regions, and so on. We define the model and describe an algorithm that checks for the existence of a model for a given set of formulas based on this model. We prove the soundness and completeness of the algorithm and apply it to an example that inspects the causality of contamination in 2D space.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0910

Authors: Claudio Carvilhe, Martin Musicante

Abstract: Action Semantics is a framework for the formal specification of programming languages. Two different, recently proposed approaches provide modularity to the framework, allowing for specification reusability and extension. In this work, we analyze the previous approaches, and introduce Object-Oriented Action Semantics, a new form of modular organization of Action Semantics descriptions. Object-oriented Action Semantics does not modify the syntax in which actions are written, the addition of object-oriented features (like classes and objects) is done as an upper layer to the semantic entities and functions. A simple Pascal-like, imperative programming language is described using the formalism. The extension and reuse capabilities of Object_Oriented Action Semantics are demonstrated by adding new features to the description. The semantics of the object-oriented action notation is also presented.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0891

Authors: Luís Barbosa

Abstract: This paper introduces a calculus of state-based software components modelled as concrete coalgebras for some Set endofunctors, with specified initial conditions. The calculus is parametrized by a notion of behaviour, introduced as a strong (usually commutative) monad. The proposed component model and calculus are illustrated through the characterisation of a particular class of components, classified as separable, which includes the ones arising in the so-called model oriented approach to systems design.

HTML

XML

PDF

DOI: 10.3217/jucs-008-07-0674

Authors: Demissie Aredo

Abstract: This paper presents a framework for representing formal semantics of a subset of the Unified Modeling Language (UML) notation in a higher-order logic, more specifically semantics of UML sequence diagrams is encoded into the Prototype Verification System (PVS). The primary objective of our work is to make UML models amenable to rigorous analysis by providing their precise semantics. This approach paves a way for formal development of systems through a systematic transformation of UML models. This work is a part of a long-term vision to explore how the PVS tool set can be used to underpin practical tools for analyzing UML models. It contributes to the ongoing effort to provide mathematical foundation to UML notations, with the aim of clarifying the semantics of the language as well as supporting the development of semantically-based tools.

HTML

XML

PDF

DOI: 10.3217/jucs-007-11-1024

Authors: Robert Eschbach, Uwe Glässer, Reinhard Gotzhein, Martin Löwis, Andreas Prinz

Abstract: In November 1999, the current version of SDL (Specification and Description Language), commonly referred to as SDL-2000, has passed ITU-T, an international standardization body for telecommunication. The importance and acceptance of SDL in the telecommunication industry surpasses that of UML, which can be seen as the major competitor. A crucial difference between SDL and UML is the existence of a formal SDL semantics as part of the international standard, which has a positive impact on the quality of the entire language definition. In this paper, we treat fundamental questions concerning practicability, adequacy and maintainability of the formalization approach, provide insights into the formal semantics definition and point out several effects on the SDL standard.

HTML

XML

PDF

DOI: 10.3217/jucs-007-08-0641

Authors: Dines Bjørner

Abstract: We present the didactic bases for a different kind of text book on Software Engineering - one that is based on semiotics, proper description principles, informal narrations and formal specifications, on phase, stage and stepwise development from developing understandings of the domain, via requirements to software design. Each of the concepts: Semiotics, description, documents, abstraction & modelling, domains, requirements and software design, are covered systematically while enunciating a number of method principles for selecting and applying techniques and tools for the effcient construction of efficient software. The proposed textbook presents many, what are believed to be novel development concepts: Domain engineering with its emphasis on domain attributes, stake{holder perspectives and domain facets (intrinsics, support technologies, management & organization, rules & regulation, human behaviour, etc.), requirements engineering with its decomposition into domain requirements (featuring such techniques as projection, instantiation, extension and initialization), interface requirements and machine requirements, etc.

HTML

XML

PDF

DOI: 10.3217/jucs-007-08-0631

Authors: Cliff Jones

Abstract: This paper describes (one person's view of) how the Vienna Development Method grew out of the earlier work on the Vienna Definition Language. Both of these activities were undertaken at the IBM Laboratory Vienna during the 1960s and 70s.

HTML

XML

PDF

DOI: 10.3217/jucs-007-01-0037

Authors: Heinz Treseler, Olaf Stursberg, Paul W. H. Chung, Shuanghua Yang

Abstract: The paper presents a tool architecture which supports the formal verification of logic controllers for processing systems. The tool's main intention is to provide a front-end for modelling the controller as well as the processing systems. The models are automatically transformed into representations which can be analysed by existing model checking algorithms. While the first part of the paper gives an overview of the complete architecture, the second part introduces a newly developed modelling interface: Process Control Event Diagrams (PCEDs) are formally defined as a suitable means to represent the flow of information in controlled processes. The transformation of PCEDs into verifiable code is described, and the whole procedure of modelling, model transformation and verification is illustrated with a simple processing system.

HTML

XML

PDF

DOI: 10.3217/jucs-006-11-1088

Authors: Issa Traoré

Abstract: The current UML standard provides definitions for the semantics of its components. These definitions focus mainly on the static structure of UML, but they don t include an execution semantics. These definitions include several semantic variation points leaving out the door open for multiple interpretations of the concepts involved. This situation can be handled by formalizing the semantic concepts involved. In this paper we present an approach for the formalization of one of the multiple diagrams of UML, namely statechart diagrams. That is achieved by using the PVS Specification Language as formal semantics domain. We present also how the approach can be used to conduct a formal analysis using the PVS model-checker.

HTML

XML

PDF

DOI: 10.3217/jucs-006-07-0650

Authors: Constance Heitmeyer, Ramesh Bharadwaj

Abstract: To date, the SCR (Software Cost Reduction) requirements method has been used in industrial environments to specify the requirements of many practical systems, including control systems for nuclear power plants and avionics systems. This paper describes the use of the SCR method to specify the requirements of the Light Control System (LCS), the subject of a case study at the Dagstuhl Seminar on Requirements Capture, Documentation, and Validation in June 1999. It introduces a systematic process for constructing the LCS requirements specification, presents the specification of the LCS in the SCR tabular notation, discusses the tools that we applied to the LCS specification, and concludes with a discussion of a number of issues that arose in developing the specification.

HTML

XML

PDF

DOI: 10.3217/jucs-003-12-1382

Authors: Uwe Glaesser, Rene Karges

Abstract: Based on the ITU-T Recommendation Z.100 [27]---also known as SDL-92--- we define a formal semantic model of the dynamic properties of Basic SDL in terms of an abstract SDL machine. More precisely, we use the concept of multi-agent realtime ASM [17] as a semantic platform on top of which we construct our mathematical description. The resulting interpretation model is not only mathematically precise but also reflects the common understanding of SDL in a direct and intuitive manner; it provides a concise and understandable representation of the complete dynamic semantics of Basic SDL. Moreover, the model can easily be extended and modified---a particularly important issue for an evolving technical standard. In this article, we consider all relevant aspects concerning the behavior of channels, processes and timers with respect to signal transfer operations and timer operations. The model we obtain is intended as a basis for formal documentation as well as for executable high-level SDL specifications.

HTML

XML

PDF

DOI: 10.3217/jucs-003-07-0756

Authors: Richard Banach

Abstract: The suspending semantic model for the execution of the MONSTR generali sed term graph rewriting language is defined. This is the canonical operational semantic model for the MONSTR language. Its correctness with respect to DACTL semantics is discussed, a nd a number of general theorems on the soundness of suspending executions with respec t to DACTL semantics are proved. General theorems are proved about the independence of susp ending primitive actions, which are useful in the verification of MONSTR systems.

HTML

XML

PDF

DOI: 10.3217/jucs-003-05-0443

Authors: Philipp Kutter, Alfonso Pierantonio

Abstract: This paper presents the formal specification of the programming language Oberon. Using Montages we give a description of syntax, static, and dynamic semantics of all constructs of the language. The specification is arranged in five refinement steps, each of them results in a working sub-language of Oberon. The compactness and readability of the specification make us believe that it can be used for a reference manual.

HTML

XML

PDF

DOI: 10.3217/jucs-003-05-0416

Authors: Philipp Kutter, Alfonso Pierantonio

Abstract: Montages are a new way of describing all aspects of programming languages formally. Such specifications are intelligible for a broad range of people involved in programming language design and use. In order to enhance readability we combine visual and textual elements to yield specifications similar in structure, length, and complexity to those in common language manuals, but with a formal semantics. The formal semantics is based on Gurevich's Abstract State Machines (formerly called Evolving Algebras).

HTML

XML

PDF

DOI: 10.3217/jucs-002-04-0164

Authors: Richard Banach

Abstract: This is the first in a series of papers dealing with the implementation of an extended term graph rewriting model of computation (described by the DACTL language) on a distributed store architecture. In this paper we set out the high level model, and under some simple restrictions, prove an abstract packet store implementation correct modulo garbage. The abstract packet store model is compared to a more realistic and finegrained packet store model, more closely related to the properties of a genuine distributed store architecture, and the differences are used to inspire the definition of the MONSTR sublanguage of DACTL, intended for direct execution on the machine. Various alternative operational semantics for MONSTR are proposed to reflect more closely the finegrained packet store model, and the prospects for establishing correctness are discussed. The detailed treatment of the alternative models, in the context of suitable sublanguages of MONSTR where appropriate, are subjects for subsequent papers.

HTML

XML

PDF

DOI: 10.3217/jucs-001-06-0339

Authors: Richard Banach, J. Balázs, George Papadopoulos

Abstract: A translation of the pi-calculus into the MONSTR graph rewriting language is described and proved correct. The translation illustrates the heavy cost in practice of faithfully implementing the communication primitive of the pi-calculus and similar process calculi. It also illustrates the convenience of representing an evolving network of communicating agents directly within a graph manipulation formalism, both because the necessity to use delicate notions of bound variables and of scopes is avoided, and also because the standard model of graphs in set theory automatically yields a useful semantics for the process calculus. The correctness proof illustrates many features typically encountered in reasoning about graph rewriting systems, and particularly how serialisation techniques can be used to reorder an arbitrary execution into one having stated desirable properties.

HTML

XML

PDF