The idea behind GoalDebug is to allow the spreadsheet user to express
expectations about cell values using a simple interface. The system uses this information to compare the expected data with the
data computed by formulas in the spreadsheet and creates a ranked list of
suggestions for how to change cell formulas.
We have created an extension to Excel, called Gencel, that is based on the
concept of a spreadsheet template, which captures the essential structure of a
spreadsheet and all of its future evolutions. Such a template ensures that the
spreadsheet can be changed only in the the anticipated ways, so that
spreadsheets evolving from templates will provably never contain any reference,
range, or type errors. Gencel can help to reduce maintenance costs while at
the same time it dramatically increases the level of correctness and
reliability of spreadsheets.
The goal of this project is to develop type systems for spreadsheets
that (i) offer the advantages of static typing and are (ii) still
usable by end users. To this end we have defined a unit system
for spreadsheets that allows to reason about the correctness of formulas
in concrete terms, which is achieved by using concrete values
from the spreadsheet, for example, headers, as types (or units).
A particular focus of our work is the flexibility of the unit system, both in
terms of error reporting and adaptability of reasoning rules, to achieve a
high acceptance among end users.
The PFP library is a collection of modules for Haskell that facilitates
probabilistic functional programming, that is, programming with stochastic
values.
The probabilistic functional programming approach is based on a data type for
representing distributions. A distribution represent the outcome of a
probabilistic event as a collection of all possible values, tagged with their
likelihood.
A nice aspect of this system is that simulations can be specified
independently from their method of execution. That is, we can either fully simulate
or randomize any simulation without altering the code which defines it.
This project is concerned with the application of program transformationand
meta programming techniques to the problem of software maintenance and reuse.
Our goal is to develop languages in which update programs can be
written that can perform software changes automatically.
An important aspect is that these update programs should preserve properties
of the programs they change, such as syntax or type correctness.
We are developing a program generator that can create simulation programs
for ocean models depending on a characterization of these models in form of a
set of parameters. To this end, we have designed and implemented a
domain-specific language (DSL) to describe ocean modeling tools. Tool
descriptions are translated into Fortran 90 programs.
One focus in the design of the DSL is safety, that is, the DSL compiler
guarantees that generated Fortran programs are syntactically correct and, to a
large degree, also type correct.
We have designed a data model to represent spatiotemporal data, that is,
geometric information that changes over time. Based on an abstract data
type modeling approach, we have designed query languages to express
inquiries about such data. Adding a temporal dimension to spatial data
creates a huge space of possible relationships and dependencies between
spatiotemporal objects that offers a wealth of different language designs that
are still to be explored.
In addition to traditional textual query languages, we are also developing
visual query languages to simplify the construction of queries for end users.
We are developing an XML query and transformation language that is
particularly targeted at end users who have no formal training in databases
or programming. The language is based on a document metaphor and allows
simple selections in the style of "query-by-forms" as well as more
sophisticated transformations that are expressed by so-called
document rules. We are currently developing a graphical user
interface to aid the construction of queries.
We also investigate the automatic generation of XML transformations
to help users to integrate different XML data sources.
Taking an inductive view of graphs facilitates
the recursive definition of graph algorithms. One advantage of
this approach over others is that the design of algorithms can proceed in a
more declarative fashion; in particular, we do not have to care about node
markings that are inherent in the imperative style of graph algorithms and
that complicate the reasoning about programs considerably.
The convenient formulation of recursive graph algorithms builds on a
special kind of pattern matching that allows to extract particular
representations from an abstract data type.
In this project we have investigated formalisms to formally define the
meaning of visual languages. A key step is the identification of an
appropriate level of abstract visual syntax. We have also investigated
ways to specify the semantics of visual languages visually.
Generalized fold operations were originally introduced for data types as
found in Haskell or ML (which correspond to free term algebras). The scope of
folds can be extended to abstract data types if an ADT is represented by a
pair consisting of a constructor and a destructor, which are essentially
functions to/from a common representation. Then a fold can work on an ADT by
applying parameter functions to values that are delivered by the ADT's
destructor. Fold operations that use as a parameter the constructor of
another ADT, called ADT transformers,play an important role and offer a
concise programming style. Several laws for ADT folds and transformers exist
that can be used for program optimization and verification.
This project is concerned with the development of data models and query
languages to support the representation of spatial data in databases. We have
investigated models based on partitions that can serve as a fundamental core
model for spatial data. We have also investigated representations for
imprecise data and graphs.