56 research outputs found
From Process Calculi to Klaim and Back
We briefly describe the motivations and the background behind the design of Klaim, a process description language that has proved to be suitable for describing a wide range of distributed applications with agents and code mobility. We argue that a drawback of Klaim is that it is neither a programming language, nor a process calculus. We then outline the two research directions we have pursued more recently. On the one hand we have evolved Klaim to a full-fledged language for distributed mobile programming. On the other hand we have distilled the language into a number of simple calculi that we have used to define new semantic theories and equivalences and to test the impact of new operators for network aware programming
A VISUAL DESIGN METHOD AND ITS APPLICATION TO HIGH RELIABILITY HYPERMEDIA SYSTEMS
This work addresses the problem of the production of hypermedia
documentation for applications that require high reliability, particularly
technical documentation in safety critical industries. One requirement of this
application area is for the availability of a task-based organisation, which
can guide and monitor such activities as maintenance and repair. In safety
critical applications there must be some guarantee that such sequences are
correctly presented. Conventional structuring and design methods for
hypermedia systems do not allow such guarantees to be made. A formal
design method that is based on a process algebra is proposed as a solution
to this problem. Design methods of this kind need to be accessible to
information designers. This is achieved by use of a technique already
familiar to them: the storyboard. By development of a storyboard notation
that is syntactically equivalent to a process algebra a bridge is made
between information design and computer science, allowing formal analysis
and refinement of the specification drafted by information designers.
Process algebras produce imperative structures that do not map easily into
the declarative formats used for some hypermedia systems, but can be
translated into concurrent programs. This translation process, into a
language developed by the author, called ClassiC, is illustrated and the
properties that make ClassiC a suitable implementation target discussed.
Other possible implementation targets are evaluated, and a comparative
illustration given of translation into another likely target, Java
Faculty Senate Monthly Packet December 1990
The December 1990 Monthly packet includes the December agenda and appendices and the Faculty Senate minutes and attachments from the meeting held November 1990
Domain-specific languages for modeling and simulation
Simulation models and simulation experiments are increasingly complex. One way to handle this complexity is developing software languages tailored to specific application domains, so-called domain-specific languages (DSLs). This thesis explores the potential of employing DSLs in modeling and simulation. We study different DSL design and implementation techniques and illustrate their benefits for expressing simulation models as well as simulation experiments with several examples.Simulationsmodelle und -experimente werden immer komplexer. Eine Möglichkeit, dieser Komplexität zu begegnen, ist, auf bestimmte Anwendungsgebiete spezialisierte Softwaresprachen, sogenannte domänenspezifische Sprachen (\emph{DSLs, domain-specific languages}), zu entwickeln. Die vorliegende Arbeit untersucht, wie DSLs in der Modellierung und Simulation eingesetzt werden können. Wir betrachten verschiedene Techniken für Entwicklung und Implementierung von DSLs und illustrieren ihren Nutzen für das Ausdrücken von Simulationsmodellen und -experimenten anhand einiger Beispiele
A Formal Methodology for Deriving Purely Functional Programs From Z Specifications via the Intermediate Specification Language FunZ.
In recent years, both formal methods and software reuse have been increasingly advocated as a means of alleviating the ills of the software crisis. During this same time period, purely functional programming languages, which have a long history in the realm of rapid prototyping, have emerged as a viable medium for real-world applications. Since these trends are likely to continue, this work describes a methodology that facilitates the derivation of purely functional programs from existing Z specifications. A unique aspect of the methodology is its incorporation of an intermediate specification language (FunZ) during the design phase of software development. Most of the previous techniques for translating Z specifications to functional programs were designed primarily to expedite rapid prototyping. In contrast, the FunZ methodology, which is an adapted form of the IBM Hursley method, is a comprehensive approach, spanning the software life cycle from specification through design to final implementation. Due to its greater scope, the FunZ methodology offers several advantages over existing approaches. First, the specification language integrates features from Z with those of the functional programming paradigm to provide a bridge between Z specifications and functional implementations. Since FunZ is expressly designed to target functional languages, the implementor\u27s job is simplified. In fact, a FunZ document looks like extended Haskell code, so an obvious effect in applying FunZ is that the distance from design to code is reduced. Second, the methodology provides a framework for recording design decisions, which is useful for future maintenance. Within this framework, users may select a development path ranging from an intuitive style to a fully formal approach that includes the proofs of functional refinement. Furthermore, FunZ allows software developers to prove properties about a system design within the realm of Z or Haskell. This means that proofs can be performed throughout software development and the designer is free to select the most appropriate notation. In summary, the intermediate specification language FunZ and its related methodology provide software developers with a complete, formal approach for translating Z specifications to Haskell implementations. Previously, such extensive methods were only available for traditional, imperative languages
Entwurf funktionaler Implementierungen von Graphalgorithmen
Classic graph algorithms are usually presented and analysed
in imperative programming languages.
Imperative programming languages are well-suited for the description of
a program flow,
in which the order in which the operations are performed is important.
One common example of such a description is the successive,
typically destructive modification of objects.
This kind of iteration often occurs in the context of graph algorithms
that deal with a certain kind of optimisation.
In functional programming,
the order of execution is abstracted
and problem solutions are described
as compositions of intermediate solutions.
Additionally,
functional programming languages are referentially transparent
and thus destructive updates of objects are discouraged.
The development of purely functional graph algorithms begins with the
decomposition of a given problem into simpler problems.
In many cases
the solutions of these partial problems can be used to solve
different problems as well.
What is more,
this compositionality allows exchanging functions
for more efficient or more comprehensible versions with little effort.
An algebraic approach with a focus on relation algebra as defined by Tarski
is used as an intermediate step in this dissertation.
One advantage of this approach is the formality of the resulting specifications.
Despite their formality,
the resulting expressions are still readable,
because the algebraic operations have intuitive interpretations.
Another advantage is that the specification is executable,
once the necessary operations are implemented.
This dissertation presents the basics of the algebraic approach in the
functional programming language Haskell.
Using this foundation,
some exemplary graph-theoretic problems are solved in the presented
framework.
Finally,
optimisations of the presented implementations are discussed
and pointers are provided to further problems
that can be solved using the above methods.Klassische Graphalgorithmen werden ĂĽblicherweise in imperativen
Programmiersprachen
beschrieben und analysiert.
Imperative Programmiersprachen eignen sich gut,
um Programmabläufe zu beschreiben,
in welchen die Reihenfolge der Operationen
wichtig ist.
Dies betrifft insbesondere die schrittweise,
in der Regel destruktive Veränderung von Objekten,
wie sie häufig im Falle von Optimierungsproblemen
auf Graphen vorkommt.
In der funktionalen Programmierung abstrahiert man von einer festen
Berechnungsreihenfolge und beschreibt Problemlösungen als
Kompositionen von Teillösungen.
Ferner sind funktionale Programmiersprachen referentiell transparent,
sodass destruktive Veränderungen nur bedingt möglich sind.
Die Entwicklung rein funktionaler Graphalgorithmen setzt bei der Zerlegung
der bestehenden Probleme in einfachere Probleme an.
Oftmals können Lösungen dieser Teilprobleme auch in anderen
Situationen eingesetzt werden.
Darüber hinaus erlaubt es diese Kompositionalität,
einzelne Funktionen mit wenig Aufwand durch effizientere
oder verständlichere Fassungen
auszutauschen.
Als Zwischenschritt in der Entwicklung wird in dieser Dissertation
ein algebraischer Ansatz basierend auf der Relationenalgebra im Sinne von Tarski
verwendet.
Ein Vorteil dieses Ansatzes ist die
Formalität der entstehenden Spezifikationen.
Trotz ihrer Formalität bleiben die entstehenden Ausdrücke oft
leserlich,
weil die algebraischen Operationen
anschauliche Interpretationen zulassen.
Ein weiterer Vorteil ist,
dass Spezifikationen ausfĂĽhrbar werden,
sobald bestimmte Basisoperationen implementiert sind.
In dieser Dissertation werden Grundlagen einer Implementierung
des algebraischen Ansatzes in der
funktionalen Programmiersprache Haskell behandelt.
Ausgehend hiervon werden exemplarisch einige
Probleme der Graphentheorie gelöst.
SchlieĂźlich werden Optimierungen der vorgestellten Implementierungen
und weitere Probleme,
welche mit den obigen Methoden lösbar sind, diskutiert
The Timed Concurrent Constraint language in practice
We propose the tccp language for the specification and verification of security protocols. We study the relation between tccp and utcc by presenting a transformation from utcc into tccp that formally states the relation between the two languages. Finally, we present an interpreter for tccp implemented in Maude.Lescaylle Daudinot, A. (2009). The Timed Concurrent Constraint language in practice. http://hdl.handle.net/10251/14517Archivo delegad
Against the Tide. A Critical Review by Scientists of How Physics and Astronomy Get Done
Nobody should have a monopoly of the truth in this universe. The censorship and suppression of challenging ideas against the tide of mainstream research, the blacklisting of scientists, for instance, is neither the best way to do and filter science, nor to promote progress in the human knowledge. The removal of good and novel ideas from the scientific stage is very detrimental to the pursuit of the truth. There are instances in which a mere unqualified belief can occasionally be converted into a generally accepted scientific theory through the screening action of refereed literature and meetings planned by the scientific organizing committees and through the distribution of funds controlled by "club opinions". It leads to unitary paradigms and unitary thinking not necessarily associated to the unique truth. This is the topic of this book: to critically analyze the problems of the official (and sometimes illicit) mechanisms under which current science (physics and astronomy in particular) is being administered and filtered today, along with the onerous consequences these mechanisms have on all of us.\ud
\ud
The authors, all of them professional researchers, reveal a pessimistic view of the miseries of the actual system, while a glimmer of hope remains in the "leitmotiv" claim towards the freedom in doing research and attaining an acceptable level of ethics in science
- …