KeY is a tool that provides facilities for formal specification and verification of programs within a commercial platform for UML based software development. Using the KeY tool, formal methods and object-oriented development techniques are applied in an integrated manner. Formal specification is performed using the Object Constraint Language (OCL), which is part of the UML standard. KeY provides support for the authoring and formal analysis of OCL constraints. The target language of KeY based development is JAVA CARD, a proper subset of JAVA for smart card applications and embedded systems. KeY uses a dynamic logic for JAVA CARD to express proof obligations, and provides a state-of-the-art theorem prover for interactive and automated verification. Apart from its integration into UML based software development, a characteristic feature of KeY is that formal specification and verification can be introduced incrementally.

Abstract not found

Abstract. We describe a system for automatically translating formal software specifications to natural language. The system produces natural language which is acceptable to a human reader, and it supports byhand optimization by users who are not experts of our system. The translation system is implemented using the Grammatical Framework, a grammar formalism based on Martin-Löf’s type theory. We show that this grammar-based approach scales well enough to handle a non-trivial case study: translating the Object Constraint Language specifications of the Java Card API into English. 1

Abstract. KeY is a tool that provides facilities for formal specification and verification of programs within a commercial platform for UML based software development. Using the KeY tool, formal methods and object-oriented development techniques are applied in an integrated manner. Formal specification is performed using the Object Constraint Language (OCL), which is part of the UML standard. KeY provides support for the authoring and formal analysis of OCL constraints. The target language of KeY based development is Java Card DL, a proper subset of Java for smart card applications and embedded systems. KeY uses a dynamic logic for Java Card DL to express proof obligations, and provides a state-of-the-art theorem prover for interactive and automated verification. Apart from its integration into UML based software development, a characteristic feature of KeY is that formal specification and verification can be introduced incrementally. Keywords: Object-oriented design – Formal specification – Formal verification – UML – OCL – Design patterns – Java 1

Abstract. With the advent of Model Driven Architecture, OCL constraints are no longer necessarily written by humans. They can be part of models that emerge from a chain of transformations. They might be the result of instantiating templates, of combining prefabricated parts, or of more general computation. Such generated specifications will often contain redundancies that reduce their readability. In this paper, we explore the possibilities of transforming OCL formulae to a simpler form through the repeated application of simple rules. We discuss the different kinds of rules that are needed, and we describe a prototypical implementation of the approach. 1

The construction of natural language interfaces to computers continues to be a major challenge. The need for such interfaces is growing now that speech recognition technology is becoming more readily available, and people cannot speak those computer-oriented formal languages that are frequently used to interact with computer applications. Much of the research related to the design and implementation of natural language interfaces has involved the use of high-level declarative programming languages. This is to be expected as the task is extremely difficult, involving syntactic and semantic analysis of potentially ambiguous input. The use of LISP and Prolog in this area is well documented. However, research involving the relatively new lazy functional programming paradigm is less well known. This paper provides a comprehensive survey of that research.

Abstract. To help designers in writing OCL constraints, we have to construct systems that can generate some of these constraints. This might be done by instantiating templates, by combining prefabricated parts, or by more general computation. Such generated specifications will often contain redundancies that reduce their readability. In this paper, we explore the possibilities of simplifying OCL formulae through the repeated application of simple rules. We discuss the different kinds of rules that are needed, and we describe a prototypical implementation of the approach. 1 Introduction The Object Constraint Language (OCL) [12] is designed with human authors and readers in mind. While some of todays UML tools allow attaching OCL constraints to diagrams and allow to check their syntax with a parser, there is practically no support for authoring OCL specifications. But writing good specifications is hard, and as the software to be specified becomes larger and more complex, designers will need tools that help them with that task.

The topic of this thesis is to bridge the gap between formal and informal software specifications. Formal specifications are required for the use of formal methods to verify the correctness of software. If we expect formal methods to be used in realistic software development projects, we need to enable people with varying levels of familiarity with formal specification languages to understand, maintain and create formal specifications. To address these problems, we provide a tool for translating specifications written in the formal language OCL, a substandard of UML, to natural language. We also provide a multilingual, syntax-directed editor where OCL and natural language specifications can be edited in parallel. The implementation of our work is to a large extent based on the Grammatical Framework (GF). GF is a grammar formalism based on type theory, which provides a special purpose language for defining grammars, and a compiler for this language. We have developed a GF grammar for specifications

Abstract. The Object Constraint Language (OCL) is often used for behavioral specification of software components. One current problem in specifying behavioral aspects comes from the fact that editing OCL constraints manually is time consuming and error-prone. To simplify constraint definition we propose to use specification patterns for which OCL constraints can be generated automatically. In this paper we outline this solution proposal and develop a way how to formally describe such specification patterns on which a library of reusable OCL specifications is based.

summary – This paper aims to show how Montague-style grammars can be completely formalized and thereby declaratively implemented by using the Grammatical Framework GF. The implementation covers the fundamental operations of Montague’s PTQ 4 model: the construction of analysis trees, the linearization of trees into strings, and the interpretation of trees as logical formulas. Moreover, a parsing algorithm is derived from the grammar. Given that GF is a constructive type theory with dependent types, the technique extends from classical Montague grammars to ones in which the Curry-Howard isomorphism is used to explain anaphoric reference. On the other hand, GF has a built-in compositionality requirement that is stronger than in PTQ and prevents us from formulating quantifying-in rules of Montague style. This leads us to alternative formulations of such rules in terms of combinators and discontinuous constituents. The PTQ fragment will moreover be presented as an example of how a GF grammar is modified by replacing English with another target language, French. The paper concludes by a discussion of the complementary rôles of logically and linguistically oriented syntax.