2,994 research outputs found
Parameter passing in algebraic specification languages
AbstractIn this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied (matrix(int)) or a nested (bintree(string())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration
A parameterization process as a categorical construction
The parameterization process used in the symbolic computation systems Kenzo
and EAT is studied here as a general construction in a categorical framework.
This parameterization process starts from a given specification and builds a
parameterized specification by transforming some operations into parameterized
operations, which depend on one additional variable called the parameter. Given
a model of the parameterized specification, each interpretation of the
parameter, called an argument, provides a model of the given specification.
Moreover, under some relevant terminality assumption, this correspondence
between the arguments and the models of the given specification is a bijection.
It is proved in this paper that the parameterization process is provided by a
free functor and the subsequent parameter passing process by a natural
transformation. Various categorical notions are used, mainly adjoint functors,
pushouts and lax colimits
The Larch/Smalltalk Interface Specification Language
Object-oriented programming languages, such as Smalltalk, help one to build reusable program modules. The reuse of program modules requires adequate documentation --- formal or informal. Larch/Smalltalk is a formal specification language for specifying such reusable Smalltalk modules. Larch/Smalltalk firmly separates specification from implementation. In Larch/Smalltalk, the unit of specification is an abstract data type, which is an abstraction of the behavior produced by one or more Smalltalk classes. A type can be a subtype of other types, which allows types to be organized based on specified behavior, and also allows for inheritance of their specifications. Larch/Smalltalk specifications are developed using specification tools integrated in the Smalltalk programming environment
Rascal: From Algebraic Specification to Meta-Programming
Algebraic specification has a long tradition in bridging the gap between
specification and programming by making specifications executable. Building on
extensive experience in designing, implementing and using specification
formalisms that are based on algebraic specification and term rewriting (namely
Asf and Asf+Sdf), we are now focusing on using the best concepts from algebraic
specification and integrating these into a new programming language: Rascal.
This language is easy to learn by non-experts but is also scalable to very
large meta-programming applications.
We explain the algebraic roots of Rascal and its main application areas:
software analysis, software transformation, and design and implementation of
domain-specific languages. Some example applications in the domain of
Model-Driven Engineering (MDE) are described to illustrate this.Comment: In Proceedings AMMSE 2011, arXiv:1106.596
CASL for CafeOBJ Users
Casl is an expressive language for the algebraic specificationof software requirements, design, and architecture. It has been developed by an open collaborative effort called CoFI (Common Framework Initiative for algebraic specification and development). Casl combines the best features of many previous main-stream algebraic specification languages, and it should provide a focus for future research and development in the use of algebraic techniques, as well facilitating interoperability ofexisting and future tools. This paper presents Casl for users of the CafeOBJ framework, focusing on the relationship between the two languages. It first considers those constructs of CafeOBJ that have direct counterparts in Casl, and then (briefly) those that do not. It also motivates various Casl constructsthat are not provided by CafeOBJ. Finally, it gives a concise overview of Casl, and illustrates how some CafeOBJ specifications may be expressed in Casl
Type-Theoretic Signatures for Algebraic Theories and Inductive Types
We develop the usage of certain type theories as specification languages for
algebraic theories and inductive types. We observe that the expressive power of
dependent type theories proves useful in the specification of more complicated
algebraic theories. We describe syntax and semantics for three classes of
algebraic theories: finitary quotient inductive-inductive theories, their
infinitary generalization, and finally higher inductive-inductive theories. In
each case, an algebraic signature is a typing context or a closed type in a
specific type theory
Phobos: A front-end approach to extensible compilers (long version)
This paper describes a practical approach for implementing certain types of domain-specific languages with extensible compilers. Given a compiler with one or more front-end languages, we introduce the idea of a "generic" front-end that allows the syntactic and semantic specification of domain-specific languages. Phobos, our generic front-end, offers modular language specification, allowing the programmer to define new syntax and semantics incrementally
CafeOBJ: Logical Foundations and Methodologies
CafeOBJ is an executable industrial strength multi-logic algebraic specification language which is a modern successor of OBJ and incorporates several new algebraic specification paradigms. In this paper we survey its logical foundations and present some of its methodologies
Behavioral types in programming languages
A recent trend in programming language research is to use behav- ioral type theory to ensure various correctness properties of large- scale, communication-intensive systems. Behavioral types encompass concepts such as interfaces, communication protocols, contracts, and choreography. The successful application of behavioral types requires a solid understanding of several practical aspects, from their represen- tation in a concrete programming language, to their integration with other programming constructs such as methods and functions, to de- sign and monitoring methodologies that take behaviors into account. This survey provides an overview of the state of the art of these aspects, which we summarize as the pragmatics of behavioral types
- …