A basic dilemma in the design of a database programming language is the choice between a user-friendly language with a rich set of tailored notations for schema definitions, query expressions, etc., and a small, conceptually simple core language. We address this dilemma by proposing extensible grammars, a syntax-definition formalism for incremental language extensions and restrictions based on an initial core language.
The translation of programs written in tailored object languages into programs of a core language is defined via syntax-directed patterns. In contrast to traditional macro-expansion and program-rewriting tools, our extensible grammars respect scoping rules. Therefore, it is possible to introduce new binding constructs like quantifiers, iterators, and type declarations, while avoiding problems with variable captures and name clashes.
We develop extensible grammars and illustrate their use by extending the lambda calculus with let-bindings, conditionals, and SQL-style query expressions. We then give a formal description of the underlying parsing, transformation, and substitution rules. We also highlight some implementation details of a type-safe, extensible parser package based on the concept of extensible grammars developed for the Tycoon programming environment.
Persistent threads are a database programming concept particularly well-suited for applications that manage long-term, distributed or cooperative activities. We introduce persistent threads as a novel form of bindings from data in persistent object stores to activated code and relate them to existing binding concepts found in database programming. We also describe the integration of persistent threads into a polymorphically-typed database language and its supporting layered system architecture with particular emphasis on abstractly-defined thread representations which support thread analysis, optimization and portability.
In offenen verteilten Systemen wird zukünftig eine Vielzahl bekannter sowie unbekannter Dienste angeboten werden. Um diese Dienste effektiv und effizient nutzen zu können, sind adäquate Unterstützungsmechanismen für die Dienstvermittlung, die Dienstverwaltung, die Dienstkontrolle und den Zugriff auf die Dienste erforderlich. Zur Realisierung dieser Aufgaben stellen wir in dieser Arbeit die von uns entwickelte COSM/TRADE-Architektur vor, wobei der Schwerpunkt in der Betrachtung der Vermittlung und Verwaltung sogenannter klassifizierter Dienste durch den TRADE-Traders liegt.
The increased availability of global communication infrastructures allows providers and users of various application services to cooperate in nearly unlimited geographic scopes. Problems of heterogeneity and scale have motivated specific standardisation activities for client/server "trading" or service "mediation" components. Motivated by current limitations of the emerging ODP (Open Distributed Processing) trader, this paper argues for a broader concept of general service "mediation" as more appropriate for realistic open distributed environments. The proposed mediation concept addresses some of the heterogeneity and flexibility requirements of open service co-operation by a uniform "Service Interface Description Language" (SIDL). The goal is to support distributed application development for a "Common Open Service Market" (COSM) by facilitating flexible service selection and client/server interaction.
The paper also presents basic components of a generalised trading and mediation architecture as well as the status of a prototype implementation.
Dem Trader als wichtiger Basisdienst offener verteilter Systeme kommt zunehmend eine zentrale Bedeutung zu. Angesichts der Komplexität verteilter Systeme und der Vielzahl und Vielfältigkeit der angebotenen Dienste bietet der Trader adäquate Konzepte zur Strukturierung der Dienste an und stellt Mechanismen für die Dienstvermittlung und -verwaltung bereit. Dieser Artikel stellt die Funktionalität und Implementierung des TRADE-Traders vor, welcher im Rahmen des COSM/TRADE-Projektes an der Universität Hamburg prototypisch auf Basis des Distributed Computing Environment DCE realisiert ist. Am Beispiel der Implementierung des TRADE-Traders wird im vorliegenden Beitrag gezeigt, wie eine modulare Erweiterung bestehender verteilter Systemarchitekturen um Funktionen des Tradings und eine weitgehende Integration mit den bereits durch die Systemarchitektur bereitgestellten Diensten, insbesondere den vorhandenen Dienstvermittlungs- und Verwaltungsdiensten, erreicht werden kann.
A gateway from DBPL (being a superset of Modula-2) to the commercial database system Ingres is described. DBPL extends Modula-2 by a new bulk data type constructor ``relation'', persistence, and high-level relational expressions (queries) based on the predicate calculus, thereby maintaining the basic concepts of the language like strong typing and orthogonality. The gateway enables the user to write ``normal'' DBPL programs for accessing Ingres databases. This is in contrast to typical implementations that embed SQL statements into a programming language and results in a fully transparent interface for DBPL programmers. DBPL queries and statements referring to Ingres tables are automatically converted into corresponding SQL statements, are evaluated by the Ingres database server and the results are transferred back under the control of the DBPL program. This procedure also resolves queries referring to both Ingres and DBPL tables. The design assumptions of the gateway and the used implementation methods are presented as well as design and implementation difficulties.
System security services like authentication, access control and auditing are becoming increasingly critical for information systems particularly in distributed heterogeneous environments. Since information system architectures are moving rapidly from centralized, grand unifying architectures towards open, service-oriented and communication-based environments (``Persistent Object Systems'') constructed with well-organized component technologies it is essential that such structural changes are reflected adequately in the architecture of system security services.
In this paper we present an open, library-based approach to the security of Persistent Object Systems which generalizes and unifies the protection mechanisms that traditionally come bundled with database, communication or operating system services. More specifically, we illustrate how polymorphic typing can be exploited to abstract from particular commercially available security services, such as Kerberos, and how higher-order functions allow the user to add value to existing security services. Furthermore, we demonstrate how higher-order functions, first-class modules and reflection provide a technical framework for the realization of domain-specific security policies and for the systematic construction of security-enhanced activities.
In the DBPL project we tackled the problem of supporting data-intensive applications in a single framework, clean and simple in its conceptual foundation and free of technical mismatches. Conceptually, we based the DBPL language on Modula-2 with three built-in extensions which, at that time, were considered necessary (and sufficient) for data-intensive applications:
In implementing the DBPL system we adopted a rather strict approach by aiming for
As a consequence, the DBPL project covers in a quite natural way approaches otherwise considered disjoint as, for example, complex objects, multibases and data deduction.
In this paper, besides reporting on project achievements and spin-offs, we also present our insight in good-quality project design and its dependency on conceptual simplicity and implementational strictness. This also includes early recognition of the essential project ``terminator'' which, in our project, was Modula-2's monomorphic type system and its intrinsic restrictions on systems extensibility.
The DBPL project results in a mature product for modular database application programming and a follow-up project based on polymorphic types and other higher-order concepts