Object Algebra Research Articles

Castor: Programming with extensible generative visitors

Much recent work on type-safe extensibility for Object-Oriented languages has focused on design patterns that require modest type system features. Examples of such design patterns include Object Algebras , Extensible Visitors , Finally Tagless interpreters , or Polymorphic Embeddings . Those techniques, which often use a functional style, can solve basic forms of the Expression Problem. However, they have important limitations. This paper presents Castor : a Scala framework for programming with extensible, generative visitors. Castor has several advantages over previous approaches. Firstly, Castor comes with support for (type-safe) pattern matching to complement its visitors with a concise notation to express operations. Secondly, Castor supports type-safe interpreters (à la Finally Tagless), but with additional support for pattern matching and a generally recursive style. Thirdly, Castor enables many operations to be defined using an imperative style, which is significantly more performant than a functional style (especially in the JVM platform). Finally, functional techniques usually only support tree structures well, but graph structures are poorly supported. Castor supports type-safe extensible programming on graph structures. The key to Castor 's usability is the use of annotations to automatically generate large amounts of boilerplate code to simplify programming with extensible visitors. To illustrate the applicability of Castor we present several applications and two case studies. The first case study compares the ability of Castor for modularizing the interpreters from the “Types and Programming Languages” book with previous modularization work. The second case study on UML activity diagrams illustrates the imperative aspects of Castor , as well as its support for hierarchical datatypes and graphs. • A Scala framework for programming with concise, exhaustive, extensible and composable visitors. • Support for pattern matching and type-safe interpreters (à la Finally Tagless). • Support both functional and imperative style visitors. • Support for extensible programming on graphs. • Case studies on “Types and Programming Languages” and UML Activity Diagrams.

SEVENTEENTH-CENTURY SCHOLASTIC SYLLOGISTICS. BETWEEN LOGIC AND MATHEMATICS?

AbstractThe seventeenth century can be viewed as an era of (closely related) innovation in the formal and natural sciences and of paradigmatic diversity in philosophy (due to the coexistence of at least the humanist, the late scholastic, and the early modern tradition). Within this environment, the present study focuses on scholastic logic and, in particular, syllogistic. In seventeenth-century scholastic logic two different approaches to logic can be identified, one represented by the Dominicans Báñez, Poinsot, and Comas del Brugar, the other represented by the Jesuits Hurtado, Arriaga, Oviedo, and Compton. These two groups of authors can be contrasted in three prominent features. First, in the role of the theory of validity, which is either a common basis for all particular theories (in this case, sentential logic and syllogistic), or a set of observations regarding a particular theory (in this case, syllogistic). Second, in the view of syllogistic, which is either an implication of a general theory of validity and a semantics of terms, or an algebra of structured objects. Third, in the role of the scholastic analysis of language in terms ofsuppositio, which either is a semantic underpinning of syllogistic, or it is replaced by a semantics of propositions.

The complex sinh-Gordon model: form factors of descendant operators and current-current perturbations

We study quasilocal operators in the quantum complex sinh-Gordon theory in the form factor approach. The free field procedure for descendant operators is developed by introducing the algebra of screening currents and related algebraic objects. We work out null vector equations in the space of operators. Further we apply the proposed algebraic structures to constructing form factors of the conserved currents Tk and Θk. We propose also form factors of current-current operators of the form TkT−l. Explicit computations of the four-particle form factors allow us to verify the recent conjecture of Smirnov and Zamolodchikov about the structure of the exact scattering matrix of an integrable theory perturbed by a combination of irrelevant operators. Our calculations confirm that such perturbations of the complex sinh-Gordon model and of the ℤN symmetric Ising models result in extra CDD factors in the S matrix.

Functional Implementation of Multiple Traversals Program with Attribute Grammars in Scala

Attribute grammars are a powerful specification paradigm for many language processing tasks, particularly the semantic analysis of programming languages. To functionally evaluate attributes grammar in Scala, the studies to date combine Scala with Kiama. Another study relies on object algebra, is implemented in Scala but with multiple evaluation of attributes. The purpose of this study is to use only the Scala language, in order to provide a solution to the multiple traversals of derivation trees. This approach extends the object algebra with the visit-sequences which let us increase the number of folding, thus avoid the multiple evaluation of some attributes, and the result obtained from this experience gives way to the functional modeling of interactive systems. The illustration is made on the Repmin problem.

Recaf: Java dialects as libraries

Mainstream programming languages like Java have limited support for language extensibility. Without mechanisms for syntactic abstraction, new programming styles can only be embedded in the form of libraries, limiting expressiveness. In this paper, we present Recaf, a lightweight tool for creating Java dialects; effectively extending Java with new language constructs and user defined semantics. The Recaf compiler generically transforms designated method bodies to code that is parameterized by a semantic factory (Object Algebra), defined in plain Java. The implementation of such a factory defines the desired runtime semantics. We applied our design to produce several examples from a diverse set of programming styles and two case studies: we define i) extensions for generators, asynchronous computations and asynchronous streams and ii) a Domain-Specific Language (DSL) for Parsing Expression Grammars (PEGs), in a few lines of code.

Modular interpreters with implicit context propagation

Modular interpreters are a crucial first step towards component-based language development: instead of writing language interpreters from scratch, they can be assembled from reusable, semantic building blocks. Unfortunately, traditional language interpreters can be hard to extend because different language constructs may require different interpreter signatures. For instance, arithmetic interpreters produce a value without any context information, whereas binding constructs require an additional environment.In this paper, we present a practical solution to this problem based on implicit context propagation. By structuring denotational-style interpreters as Object Algebras, base interpreters can be retroactively lifted into new interpreters that have an extended signature. The additional parameters are implicitly propagated behind the scenes, through the evaluation of the base interpreter.Interpreter lifting enables a flexible style of modular and extensible language development. The technique works in mainstream object-oriented languages, does not sacrifice type safety or separate compilation, and can be easily automated, for instance using macros in Scala or dynamic proxies in Java. We illustrate implicit context propagation using a modular definition of Featherweight Java and its extension to support side-effects, and an extensible domain-specific language for state machines. We finally investigate the performance overhead of lifting by running the DeltaBlue benchmark program in Javascript on top of a modular implementation of LambdaJS and a dedicated micro-benchmark. The results show that lifting makes interpreters roughly twice as slow because of additional call overhead. Further research is needed to eliminate this performance penalty.

Modular interpreters for the masses: implicit context propagation using object algebras

Modular interpreters have the potential to achieve component-based language development: instead of writing language interpreters from scratch, they can be assembled from reusable, semantic building blocks. Unfortunately, traditional language interpreters are hard to extend because different language constructs may require different interpreter signatures. For instance, arithmetic interpreters produce a value without any context information, whereas binding constructs require an additional environment. In this paper, we present a practical solution to this problem based on implicit context propagation. By structuring denotational-style interpreters as Object Algebras, base interpreters can be retroactively lifted into new interpreters that have an extended signature. The additional parameters are implicitly propagated behind the scenes, through the evaluation of the base interpreter. Interpreter lifting enables a flexible style of component-based language development. The technique works in mainstream object-oriented languages, does not sacrifice type safety or separate compilation, and can be easily automated. We illustrate implicit context propagation using a modular definition of Featherweight Java and its extension to support side-effects.

Scrap your boilerplate with object algebras

Traversing complex Abstract Syntax Trees (ASTs) typically requires large amounts of tedious boilerplate code. For many operations most of the code simply walks the structure, and only a small portion of the code implements the functionality that motivated the traversal in the first place. This paper presents a type-safe Java framework called Shy that removes much of this boilerplate code. In Shy object algebras are used to describe complex and extensible AST structures. Using Java annotations Shy generates generic boilerplate code for various types of traversals. For a concrete traversal, users of Shy can then inherit from the generated code and override only the interesting cases. Consequently, the amount of code that users need to write is significantly smaller. Moreover, traversals using the Shy framework are also much more structure shy, becoming more adaptive to future changes or extensions to the AST structure. To prove the effectiveness of the approach, we applied Shy in the implementation of a domain-specific questionnaire language. Our results show that for a large number of traversals there was a significant reduction in the amount of user-defined code.

From object algebras to attribute grammars

Oliveira and Cook (2012) and Oliveira et al. (2013) have recently introduced object algebras as a program structuring technique to improve the modularity and extensibility of programs. We analyze the relationship between object algebras and attribute grammars (AGs), a formalism to augment context-free grammars with attributes. We present an extension of the object algebra technique with which the full class of L-attributed grammars - an important class of AGs that corresponds to one-pass compilers - can be encoded in Scala. The encoding is modular (attributes can be defined and type-checked separately), scalable (the size of the encoding is linear in the size of the AG specification) and compositional (each AG artifact is represented as a semantic object of the host language). To evaluate these claims, we have formalized the encoding and re-implemented a one-pass compiler for a subset of C with our technique. We also discuss how advanced features of modern AG systems, such as higher-order and parameterized attributes, reference attributes, and forwarding can be supported.

Extensible language implementation with object algebras (short paper)

Object Algebras are a recently introduced design pattern to make the implementation of recursive data types more extensible. In this short paper we report our experience in using Object Algebras in building a realistic domain specific language (DSL) for questionnaires, called QL. This experience has led to a simple, yet powerful set of tools for the practical and flexible implementation of highly extensible languages.

Cloud Algebra for Handling Unstructured Data in Cloud Database Management System

The handling of unstructured data in database management s ystem is very difficult. The managing unstructured data like image, video textual data etc. are not easy task in database system. In this work a concept of cloud algebra introduced to handle unstructured data in CDBMS. The most popular concept, relational algebra is used in relational database management system. The relational algebra is helpful in query processing in SQL. Another concept, Object Algebra which is used in object oriented database management system for query processing. The object algebra isuseful to manage the object in object oriented database management system. Now the concept of Cloud computing is introduced in new the era of computer technology. The concept of cloud is also introduced in the field of databases. The cloud database management system is newly introduced in the field of database technology to manage the cloud data. This work introduces the concept of cloud algebra for handling unstructured data the cloud database management system. This work proposed the concept of cloud alge bra for query processing for unstructured data in the cloud. The data are spread over the internet as cloud. The creation of new cloud of unstructured data and setting the relationship among various cloud of unstructured data are facilitated by cloud algebra. The updating, deleting and retrieval of unstructured data in cloud are done by cloud algebra. The cloud algebra provides powerful computation while using the query processing in CDBMS for handling unstructured data.

The equivalent expression between the OODB query language OQL and the object algebra.

The equivalent expression between the OODB query language OQL and the object algebra.

New axioms for rigorous Bayesian probability

By basing Bayesian probability theory on flve axioms, we can give a trivial proof of Cox's Theorem on the product rule and sum rule for conditional plausibility without assuming continuity or difierentiablity of plausibility. Instead, we extend the notion of plausibility to apply to unknowns, giving them plausi- ble values. Thus, we combine the best aspects of two approaches to Bayesian probability theory, namely the Cox-Jaynes theory and the de Finetti theory. The problem of developing the foundations of Laplacian or Bayesian probability has led to many difierent approaches, which are mainly variations on two. The flrst, which is our main concern is due to R. T. Cox (1961). The second is due to Bruno de Finetti (1974), de Finetti (1975) and a concise general treatment is in Regazzini (1985). We flnd that by combining aspects of both, we can substantially weaken the assumptions and arrive at a proof of the problematic Cox theorem which is very simple, in fact trivial, as it should be. This triviality is of the utmost importance. The foundational axioms assumed by de Finetti for conditional expectation (his conditional prevision) require a positive normalized linear functional on a partially ordered commutative algebra (with identity element and over the reals) of objects more general than random variables which he calls \random quantities and which we will simply call \unknowns or \unknown numerical quantities. Even though it is not explicitly pointed out axiomatically, de Finetti, in his discussion in the flrst two chapters of his book, assumes that the ordering of the lattice of idempotents is inherited from that of the algebra. To deflne his conditional prevision, he requires a coherence condition (see also Regazzini (1985)) equivalent to a quadratic minimization property assumed to be satisfled by the choice of previsions. We merely assume the existence of some form of rules and demonstrate that if the assignment of plausible value (what de Finetti calls \prevision) is required to be logically consistent, then the actual rules themselves are uniquely determined. In particular, as a conse- quence, the rules of conditional expectation in Bayesian probability theory are uniquely determined by the requirement of logical consistency. Thus we flnd a trivial proof of the Cox Theorem, which properly understood, is a uniqueness theorem, and we show that the theory of de Finetti is a consequence. That is, de Finetti assumes his coherence condition, meaning existence of a positive linear functional which also satisfles a cer- tain quadratic minimization criteria, and he uses the quadratic minimization criteria to

From loop groups to 2-groups

We describe an interesting relation between Lie 2-algebras, the Kac– Moody central extensions of loop groups, and the group String(n). A Lie 2-algebra is a categorified version of a Lie algebra where the Jacobi identity holds up to a natural isomorphism called the ‘Jacobiator’. Similarly, a Lie 2-group is a categorified version of a Lie group. If G is a simply-connected compact simple Lie group, there is a 1-parameter family of Lie 2-algebras gk each having g as its Lie algebra of objects, but with a Jacobiator built from the canonical 3-form on G. There appears to be no Lie 2-group having gk as its Lie 2-algebra, except when k = 0. Here, however, we construct for integral k an infinite-dimensional Lie 2-group PkG whose Lie 2-algebra is equivalent to gk. The objects of PkG are based paths in G, while the automorphisms of any object form the level-k Kac– Moody central extension of the loop group G. This 2-group is closely related to the kth power of the canonical gerbe over G. Its nerve gives a topological group |PkG| that is an extension of G by K(Z,2). When k = ±1, |PkG| can also be obtained by killing the third homotopy group of G. Thus, when G = Spin(n), |PkG| is none other than String(n).

Algebra for Fuzzy Object Oriented Database Language

The authors present an object algebra for manipulating complex objects in fuzzy object-oriented database systems. Unlike in most of the existing query languages, the design of this object algebra is based on the type and set aspects of the class. A framework is presented for executing set-theoretic operations, namely union, intersection, and difference, on the class construct. The set operations on the membership of the corresponding class containing fuzzy objects are developed by using the truth-value of the object and object identity. The type description of the resulting class derived by a set operation is specified. The authors also discuss the inheritance property characteristic for the derived class with fuzzy objects.

Algebra for Fuzzy Object Oriented Database Language

AbstractThe authors present an object algebra for manipulating complex objects in fuzzy object-oriented database systems. Unlike in most of the existing query languages, the design of this object algebra is based on the type and set aspects of the class. A framework is presented for executing set-theoretic operations, namely union, intersection, and difference, on the class construct. The set operations on the membership of the corresponding class containing fuzzy objects are developed by using the truth-value of the object and object identity. The type description of the resulting class derived by a set operation is specified. The authors also discuss the inheritance property characteristic for the derived class with fuzzy objects.

A graphical query language: VISUAL and its query processing

This paper describes VISUAL, a graphical icon-based query language with a user-friendly graphical user interface for scientific databases and its query processing techniques. VISUAL is suitable for domains where visualization of the relationships is important for the domain scientist to express queries. In VISUAL, graphical objects are not tied to the underlying formalism; instead, they represent the relationships of the application domain. VISUAL supports relational, nested, and object-oriented models naturally and has formal basis. For ease of understanding and for efficiency reasons, two VISUAL semantics are introduced, namely, the interpretation and execution semantics. Translations from VISUAL to the Object Query Language (for portability considerations) and to an object algebra (for query processing purposes) are presented. Concepts of external and internal queries are developed as modularization tools.

Rule-based schema evolution in object-oriented databases

Abstract In this paper, a rule-based mechanism for schema evolution in object-oriented databases is presented. We have benefited from having an object algebra maintaining closure that makes it possible to have the output from a query persistent in the hierarchy. The actual class hierarchy and the corresponding hierarchy which reflects the relationship between operands and results of queries are utilized. In order to have query results reflected into the class hierarchy and classes reflected into the operands hierarchy, we also define mappings between the two hierarchies. As a result, it is possible to maximize reusability in object-oriented databases. The object algebra is utilized to handle basic schema evolution functions without requiring any special set of built-in functions. The invariants and the conflict resolving rules are specified. It is also shown how other schema functions are derivable from the basic ones.

Modeling and Retrieval of Moving Objects

This paper presents a symbolic formalism for modeling and retrieving video data via the moving objects contained in the video images. The model integrates the representations of individual moving objects in a scene with the time-varying relationships between them by incorporating both the notions of object tracks and temporal sequences of PIRs (projection interval relationships). The model is supported by a set of operations which form the basis of a moving object algebra. This algebra allows one to retrieve scenes and information from scenes by specifying both spatial and temporal properties of the objects involved. It also provides operations to create new scenes from existing ones. A prototype implementation is described which allows queries to be specified either via an animation sketch or using the moving object algebra.

Query processing in DOQL: A deductive database language for the ODMG model

This paper describes the architecture, algebraic query processing framework and query execution approach that comprise the implementation of the deductive object query language (DOQL) query processing system. To the best of our knowledge, it is the first deductive object query language to be designed and implemented as a complementary and non-intrusive query component within an ODMG OODBMS architecture. The query processing framework enables the combined use of logical rewriting and algebraic optimization, and features an object algebra, local and global query optimization, physical execution algorithms implemented as iterators, and a query execution engine implemented using the dataflow technique. Several representative DOQL queries are also provided, illustrating the flexibility and expressiveness of querying object databases with DOQL.