Results 1  10
of
22
Coupled Schema Transformation and Data Conversion For XML and SQL
 In PADL 2007, volume 4354 of LNCS
, 2007
"... Abstract. A twolevel data transformation consists of a typelevel transformation of a data format coupled with valuelevel transformations of data instances corresponding to that format. We have implemented a system for performing twolevel transformations on XML schemas and their corresponding doc ..."
Abstract

Cited by 18 (7 self)
 Add to MetaCart
(Show Context)
Abstract. A twolevel data transformation consists of a typelevel transformation of a data format coupled with valuelevel transformations of data instances corresponding to that format. We have implemented a system for performing twolevel transformations on XML schemas and their corresponding documents, and on SQL schemas and the databases that they describe. The core of the system consists of a combinator library for composing typechanging rewrite rules that preserve structural information and referential constraints. We discuss the implementation of the system’s core library, and of its SQL and XML frontends in the functional language Haskell. We show how the system can be used to tackle various twolevel transformation scenarios, such as XML schema evolution coupled with document migration, and hierarchicalrelational data mappings that convert between XML documents and SQL databases. Key words: Haskell, Transformation, SQL, XML 1
Specifying strategies for exercises
 SUZUKI & F. WIEDIJK, EDS, ‘AISC/CALCULEMUS/MKM 2008’, LNAI 5144, SPRINGERVERLAG
, 2008
"... The feedback given by elearning tools that support incrementally solving problems in mathematics, logic, physics, etc. is limited, or laborious to specify. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculat ..."
Abstract

Cited by 17 (12 self)
 Add to MetaCart
The feedback given by elearning tools that support incrementally solving problems in mathematics, logic, physics, etc. is limited, or laborious to specify. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculate feedback when users make erroneous steps in a calculation. Although we need the power of a full programming language to specify strategies, we carefully distinguish between contextfree and noncontextfree sublanguages of our strategy language. This separation is the key to automatically calculating all kinds of desirable feedback.
Transformation of structureshy programs: applied to XPath queries and strategic functions, in
 PEPM’07: Proceedings of the 2007 ACM SIGPLAN Workshop on Partial Evaluation and Semanticsbased Program Manipulation, ACM
"... Various programming languages allow the construction of structureshy programs. Such programs are defined generically for many different datatypes and only specify specific behavior for a few relevant subtypes. Typical examples are XML query languages that allow selection of subdocuments without exha ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
(Show Context)
Various programming languages allow the construction of structureshy programs. Such programs are defined generically for many different datatypes and only specify specific behavior for a few relevant subtypes. Typical examples are XML query languages that allow selection of subdocuments without exhaustively specifying intermediate element tags. Other examples are languages and libraries for polytypic or strategic functional programming and for adaptive objectoriented programming. In this paper, we present an algebraic approach to transformation of declarative structureshy programs, in particular for strategic functions and XML queries. We formulate a rich set of algebraic laws, not just for transformation of structureshy programs, but also for their conversion into structuresensitive programs and vice versa. We show how subsets of these laws can be used to construct effective rewrite systems for specialization, generalization, and optimization of structureshy programs. We present a typesafe encoding of these rewrite systems in Haskell which itself uses strategic functional programming techniques.
Generic pointfree lenses
 In International Conference on Mathematics of Program Construction (MPC), Québec City, QC
, 2010
"... Abstract. Lenses are one the most popular approaches to define bidirectional transformations between data models. A bidirectional transformation with viewupdate, denoted a lens, encompasses the definition of a forward transformation projecting concrete models into abstract views, together with a ba ..."
Abstract

Cited by 16 (8 self)
 Add to MetaCart
Abstract. Lenses are one the most popular approaches to define bidirectional transformations between data models. A bidirectional transformation with viewupdate, denoted a lens, encompasses the definition of a forward transformation projecting concrete models into abstract views, together with a backward transformation instructing how to translate an abstract view to an update over concrete models. In this paper we show that most of the standard pointfree combinators can be lifted to lenses with suitable backward semantics, allowing us to use the pointfree style to define powerful bidirectional transformations by composition. We also demonstrate how to define generic lenses over arbitrary inductive data types by lifting standard recursion patterns, like folds or unfolds. To exemplify the power of this approach, we “lensify ” some standard functions over naturals and lists, which are tricky to define directly “byhand ” using explicit recursion.
Specifying Rewrite Strategies for Interactive Exercises
"... Abstract. Strategies specify how a wide range of exercises can be solved incrementally, such as bringing a logic proposition to disjunctive normal form, reducing a matrix, or calculating with fractions. In this paper we introduce a language for specifying strategies for solving exercises. This langu ..."
Abstract

Cited by 11 (11 self)
 Add to MetaCart
(Show Context)
Abstract. Strategies specify how a wide range of exercises can be solved incrementally, such as bringing a logic proposition to disjunctive normal form, reducing a matrix, or calculating with fractions. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculate feedback, for example when a user makes an erroneous step in a calculation. We can automatically generate workedout examples, track the progress of a student by inspecting submitted intermediate answers, and report back suggestions in case the student deviates from the strategy. Thus it becomes less laborintensive and less adhoc to specify new exercise domains and exercises within that domain. A strategy describes valid sequences of rewrite rules, which turns tracking intermediate steps into a parsing problem. This is a promising view at interactive exercises because it allows us to take advantage of many years of experience in parsing sentences of contextfree languages, and transfer this knowledge and technology to the domain of stepwise solving exercises. In this paper we work out the similarities between parsing and solving exercises incrementally, we discuss generating feedback on strategies, and the implementation of a strategy recognizer.
Embedding and evolution of spreadsheet models in spreadsheet systems
 in VL/HCC’11. IEEE
"... Abstract—This paper describes the embedding of ClassSheet models in spreadsheet systems. ClassSheet models are wellknown and describe the business logic of spreadsheet data. We embed this domain specific model representation on the (general purpose) spreadsheet system it models. By defining such an ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
(Show Context)
Abstract—This paper describes the embedding of ClassSheet models in spreadsheet systems. ClassSheet models are wellknown and describe the business logic of spreadsheet data. We embed this domain specific model representation on the (general purpose) spreadsheet system it models. By defining such an embedding, we provide end users a modeldriven engineering spreadsheet developing environment. End users can interact with both the model and the spreadsheet data in the same environment. Moreover, we use advanced techniques to evolve spreadsheets and models and to have them synchronized. In this paper we present our work on extending a widely used spreadsheet system with such a modeldriven spreadsheet engineering environment. I.
Calculating with lenses: Optimising bidirectional transformations
 PROCEEDINGS OF PARTIAL EVALUATION AND PROGRAM MANIPULATION
, 2010
"... This paper presents an equational calculus to reason about bidirectional transformations specified in the pointfree style. In particular, it focuses on the socalled lenses as a bidirectional idiom, and shows that many standard laws characterising pointfree combinators and recursion patterns are ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
(Show Context)
This paper presents an equational calculus to reason about bidirectional transformations specified in the pointfree style. In particular, it focuses on the socalled lenses as a bidirectional idiom, and shows that many standard laws characterising pointfree combinators and recursion patterns are also valid in that setting. A key result is that uniqueness also holds for bidirectional folds and unfolds, thus unleashing the power of fusion as a program optimisation technique. A rewriting system for automatic lens optimisation is also presented, to prove the usefulness of the proposed calculus.
Constraintaware Schema Transformation
 In The Ninth International Workshop on RuleBased Programming
, 2008
"... Abstract. Data schema transformations occur in the context of software evolution, refactoring, and crossparadigm data mappings. When constraints exist on the initial schema, these need to be transformed into constraints on the target schema. Moreover, when highlevel data types are refined to lowe ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Data schema transformations occur in the context of software evolution, refactoring, and crossparadigm data mappings. When constraints exist on the initial schema, these need to be transformed into constraints on the target schema. Moreover, when highlevel data types are refined to lower level structures, additional target schema constraints must be introduced, such as referential integrity constraints. We introduce an algebraic approach to schema transformation that is constraintaware in the sense that constraints are preserved from source to target schemas and that new constraints are introduced where needed. Our approach is based on refinement theory and pointfree program transformation. Data refinements are modeled as rewrite rules on types that carry pointfree predicates as constraints. At each rewrite step, the predicate on the reduct is computed from the predicate on the redex. An additional rewrite system on pointfree functions is used to normalize the predicates that are built up along rewrite chains. We implemented our rewrite systems in a typesafe way in the functional programming language Haskell. We demonstrate their application to constraintaware hierarchicalrelational mappings.
Report on the design of a Galculator
"... Abstract. This report presents the Galculator, a tool aimed at deriving equational proofs in arbitrary domains using Galois connections as the fundamental concept. When combined with the pointfree transform and the indirect equality principle, Galois connections offer a very powerful, generic device ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
(Show Context)
Abstract. This report presents the Galculator, a tool aimed at deriving equational proofs in arbitrary domains using Galois connections as the fundamental concept. When combined with the pointfree transform and the indirect equality principle, Galois connections offer a very powerful, generic device to tackle the complexity of proofs in program verification. We show how rewriting rules derived from the properties of the Galois connections are applied in proofs using a strategic term rewriting system which, in the current prototype, is implemented in Haskell. The prospect of integrating the Galculator with other proof assistants such as eg. Coq is also discussed.