DOI: 10.3897/jucs.141599

Authors: José de Oliveira Guimarães

Abstract: Certain languages allow a metaprogram to act as a compiler plugin and thus alter the compilation process. The metaprogram interacts with low-level details of the compiler, making its construction difficult and potentially leading to errors. Different parts of the metaprogram may have conflicting interactions, thus producing unintended outcomes. This article introduces metaprogramming in the prototype-based object-oriented language Cyan. This language provides the same core functionality as other metaprogramming systems while introducing features that improve interactions between the compiler and different components of the metaprogram. Further-more, Cyan incorporates security measures designed to circumvent typical issues encountered in metaprogramming.

HTML

PDF

DOI: 10.3217/jucs-023-10-0953

Authors: Enrique Chavarriaga, Francisco Jurado, Fernando Díez

Abstract: Domain-Specific Languages (DSLs) allow building software applications by simplifying the labour of both software engineers and domain experts thanks to the abstraction provided by a high-level code. Introducing a DSL in the software development process requires the use of technologies and frameworks in the design and implementation activities. If we are restricted to web-client applications, then XML-based languages and JavaScript frameworks and widgets are commonly used and combined in order to provide fast, robust and flexible solutions. Under this scenario, we have developed the PsiEngine, an interpreter able to evaluate programs coded in high-level XML-based DSLs (XML-DSLs) to provide solutions to domain specific problems within a web-client application. Thus, the goal of this article is to detail how we have built PsiLight, a lightweight programming language that runs on web-client. PsiLight supposes the exploratory case study we have conducted to check some features of PsiEngine, namely: multiple programs execution and data-binding capabilities in our interpreter.

HTML

XML

PDF

DOI: 10.3217/jucs-023-09-0808

Authors: Mario Bravetti

Abstract: Web Operating Systems can be seen as an extension of traditional Operating Systems where the addresses used to manage files and execute programs (via the basic load/execution mechanism) are extended from local filesystem path-names to URLs. A first consequence is that, similarly as for traditional web technologies, executing a program at a given URL can be done in two modalities: either the execution is performed client-side at the invoking machine (and relative URL addressing in the executed program set to refer to the invoked URL) or it is performed server-side at the machine addressed by the invoked URL (as, e.g., for a web service). Moreover in this context, user identification for access to programs and files and workow-based composition of service programs is naturally based on token/session-like mechanisms. We propose a middleware based on client-server protocols and on a set primitives, for managing files/resources and executing programs (in the form of client-side/server-side components/services) in Web Operating Systems, based on an extension of the REST architecture. In order to provide an unambiguous specification, we formally define the semantics of such middleware by first introducing a process algebra for standard REST and then extending it to the whole middleware.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0112

Authors: Roberto Ierusalimschy

Abstract: First-class functions are a hallmark of functional languages, but they are a useful concept in imperative languages, too. Even ANSI C offers a restricted form of first-class functions (in the form of pointers to functions), and several more recent imperative languages, such as Python 3, Go, Lua, and Swift, offer first-class, anonymous functions with lexical scoping. In most imperative languages, however, first-class functions are an advanced feature used by seasoned programmers. Lua, by contrast, uses first-class functions as a building block of the language. Lua programmers regularly benefit from diverse properties of its functions for routine constructions such as exception handling, module definitions, object-oriented programming, and iterators. Moreover, first-class functions play a central role in the API between Lua and C. In this paper, we present some aspects of Lua that were designed with first-class functions in mind, in particular its module system, exception handling, iterators, facilities for object-oriented programming, and the API between C and Lua. We also discuss how those different aspects of Lua use different properties of first-class functions to achieve two important goals in the design of Lua, namely small size and embeddability (its easiness of interfacing with other languages).

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0089

Authors: Simon Thompson

Abstract: In this paper we look back to work done in the late 1980s, and that looked at links between grammars, data types and recursion principles, and illustrating it with examples that include enumerations of types and developing a structure editor. The work is introduced by a historical foreword, and closes with an afterword that discusses some of the subsequent developments of these ideas.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0042

Authors: Shayan Najd, Simon Jones

Abstract: We study the notion of extensibility in functional data types, as a new approach to the problem of decorating abstract syntax trees with additional information. We observed the need for such extensibility while redesigning the data types representing Haskell abstract syntax inside Glasgow Haskell Compiler (GHC). Specifically, we describe a programming idiom that exploits type-level functions to allow a particular form of extensibility. The approach scales to support existentials and generalised algebraic data types, and we can use pattern synonyms to make it convenient in practice.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0021

Authors: Ralf Hinze, Clare Martin

Abstract: Almost half a century after Batcher wrote his seminal paper on sorting networks, we revisit the key algorithmic design decisions for oblivious merging to rdiscover his schemes in a disciplined way. The design space of sorting networks is eplored, resulting in a systematic reconstruction of schemes that appear in the literature in various guises.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0005

Authors: Philip Wadler

Abstract: The data abstraction mechanism of Miranda may be adapted to a dynamically typed programming language by applying ideas from gradual typing.

HTML

XML

PDF

DOI: 10.3217/jucs-021-11-1454

Authors: Ahmed Al-Zahrani, Hassan Mathkour, Hassan Abdalla

Abstract: Feature-based approaches play an important role and are widely applied in extractive summarization. In this paper, we use particle swarm optimization (PSO) to evaluate the effectiveness of different state-of-the-art features used to summarize Arabic text. The PSO is trained on the Essex Arabic summaries corpus data to determine the best particle that represents the most appropriate simple/combination of eight informative/structure features used regularly by Arab summarizers. Based on the elected features and their relevant weights in each PSO iteration, the input text sentences are scored and ranked to extract the top ranking sentences in the form of an output summary. The output summary is then compared with a reference summary using the cosine similarity function as the fitness function. The experimental results illustrate that Arabs summarize texts simply, focusing on the first sentence of each paragraph.

HTML

XML

PDF

DOI: 10.3217/jucs-019-01-0157

Authors: Santiago Vidal, Claudia Marcos

Abstract: The importance of enterprise applications in current organizations makes it necessary to facilitate their maintenance and evolution along their life. These kind of systems are very complex and they have several requirements that orthogonally crosscut the system structure (called crosscutting concerns). Since many of the enterprise systems are developed with the Spring framework, can be taken advantage of the benefit provided by the aspect-oriented module of Spring in order to encapsulate the crosscutting concerns into aspects. In this way, the maintenance and evolution of the enterprise systems will be improved. However, most of the aspect refactorings presented in the literature are not directly applicable to Spring systems. Along this line, in this work we present an adaptation of a catalog of aspect refactorings, initially presented for AspectJ, to be used with Spring/AOP. Also, we conduct a case study in which two enterprise applications developed with the Spring framework are refactored in order to encapsulate their crosscutting concerns into aspects.

HTML

XML

PDF

DOI: 10.3217/jucs-016-17-2353

Authors: Giovanni Giachetti, Manuela Albert, Beatriz Marín, Oscar Pastor

Abstract: In a model-driven development context, the definition (or selection) of an appropriate modeling language is a crucial task. OMG, in the model-driven architecture specification, recommends the use of UML for model-driven developments. However, the lack of semantic precision in UML has led to different model-driven approaches proposing their own domain-specific modeling languages in order to introduce their modeling needs. This paper focuses on customizing the UML association in order to facilitate its application in model-driven development environments. To do this, a well-defined process is defined to integrate the abstract syntax of a domain-specific modeling language that supports a precise semantics for the association construct in UML by means of the automatic generation of a UML profile. Finally, a brief example shows how the results obtained by the application of the proposed process can generate software products through a real model compilation tool.

HTML

XML

PDF

DOI: 10.3217/jucs-016-02-0315

Authors: Christophe Rhodes

Abstract: We present a number of developer tools and language extensions that are available for use with Steel Bank Common Lisp, but which are perhaps not as wellknown as they could be. Our motivation is twofold: firstly, to introduce to a developer audience facilities that can make their development or deployment of software more rapid or efficient. Secondly, in the context of the development of the Common Lisp language itself, we offer some observations of patterns of use of such extensions within the development community, and discuss the implications this has on future evolution of the language.

HTML

XML

PDF

DOI: 10.3217/jucs-016-02-0271

Authors: Pascal Costanza, Theo Hondt

Abstract: It is known that the essential ingredients of a Lisp-style unhygienic macro system can be expressed in terms of advanced hygienic macro systems. We show that the reverse is also true: We present a model of a core unhygienic macro system, on top of which a hygiene-compatible macro system can be built, without changing the internals of the core macro system and without using a code walker. To achieve this, the internal representation of source code as Lisp s-expressions does not need to be changed. The major discovery is the fact that symbol macros can be used in conjunction with local macro environments to bootstrap a hygiene-compatible macro system. We also discuss a proof-of-concept implementation in Common Lisp and give historical notes.

HTML

XML

PDF

DOI: 10.3217/jucs-016-02-0246

Authors: Didier Verna

Abstract: While software design patterns are a generally useful concept, they areoften (and mistakenly) seen as ready-made universal recipes for solving common problems. In a way, the danger is that programmers stop thinking about their actual prob-lem, and start looking for pre-cooked solutions in some design pattern book instead. What people usually forget about design patterns is that the underlying programminglanguage plays a major role in the exact shape such or such pattern will have on the surface. The purpose of this paper is twofold: we show why design pattern expressionis intimately linked to the expressiveness of the programming language in use, and we also demonstrate how a blind application of them can in fact lead to very poorlydesigned code.

HTML

XML

PDF

DOI: 10.3217/jucs-016-02-0221

Authors: Charlotte Herzeel, Pascal Costanza, Theo Hondt

Abstract: Software transactional memory (STM) is a new approach for coordinating concurrent threads, for which many different implementation strategies are currently being researched. In this paper we show that if a language implementation provides reflective access to explicit memory locations, it becomes straightforward to both (a) build an STM framework for this language and (b) to implement STM algorithms using this framework. A proof-of-concept implementation in the form of a Scheme interpreter (written in Common Lisp) is presented.

HTML

XML

PDF

DOI: 10.3217/jucs-015-03-0620

Authors: Éric Tanter, Johan Fabry

Abstract: Structural aspects modify the structure of a program, for instance by adding fields and methods to existing classes. Like behavioral aspects, which operate on execution events, structural aspects may interact and raise conflicts. Current aspect systems however do not thoroughly handle this issue. This paper discusses how complete support for structural aspect composition can be integrated in an AOP kernel, that is, a generic transformation framework on top of which aspect languages are defined. An iterative composition process is proposed that involves the programmer in a cycle of automatic detection of interactions and explicit, declarative resolution of these interactions. Beyond a general analysis of the issue of composition of structural aspects and an associated composition process, this work reports on the concrete extension of the Reflex AOP kernel to fully support the requirements drawn from our analysis. Based on a structural model supporting per-aspect subjective views, and using the power of an embedded logic engine, the result is a versatile aspect system supporting automatic detection of various kinds of structural aspect interactions, extensible reporting tools, and declarative mechanisms for the resolution of interactions between structural aspects.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3592

Authors: Fabio Tirelo, Roberto Bigonha, Joâo Saraiva

Abstract: Denotational semantics is a powerful technique to formally define programming languages. However, language constructs are not always orthogonal, so many semantic equations in a definition may have to be aware of unrelated constructs semantics. Current approaches for modularity in this formalism do not address this problem, providing, for this reason, tangled semantic definitions. This paper proposes an incremental approach for denotational semantic specifications, in which each step can either add new features or adapt existing equations, by means of a formal language based on function transformation and aspect weaving.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3556

Authors: Alexandre Skyrme, Noemi Rodriguez, Roberto Ierusalimschy

Abstract: The popularization of multi-core processors and of technologies such as hyper-threading demonstrates a fundamental change in the way processors have been evolving and also increases interest in concurrent programming, particularly as a means to improve software performance. However, concurrent programming is still considered complex, mostly due to difficulties in using the available programming models, which have been subject to recurring criticism. The increased interest in concurrency and the lack of proper models to support it stimulates the development of proposals aimed at providing alternative models for concurrent programming. In this paper, we work with some of Lua's facilities to explore such a model, based on user threads and message passing. We also demonstrate why Lua was particularly well suited for this objective, describe the main characteristics of the explored model and present a library developed to implement it, along with results of a performance evaluation.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3534

Authors: Fernando Rubbo, Rodrigo Machado, Álvaro Moreira, Leila Ribeiro, Daltro Nunes

Abstract: The latest versions of AspectJ, the most popular aspect-oriented extension for Java, must cope with the complex changes that occurred in the Java type system, specially with those that introduced type parameters for classes and methods. In this work we study the influence of raw types, i.e. parameterless instantiations of class types, over the semantics of an AspectJ-like language. As a result, we define an operational semantics and a type system for a calculus, named Raw Aspect Featherweight Generic Java (Raw-AFGJ), that represents a minimal aspect-oriented extension of Raw Featherweight Generic Java. Through our calculus it is possible to achieve a better understanding of several subtleties of aspect weaving with the restrictions imposed by raw types support in the type system.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3498

Authors: Éric Tanter

Abstract: Aspect languages provide different mechanisms to control when an aspect should apply based on properties of the execution context. They however fail to explicitly identify and cleanly capture a property as basic as that of reentrancy. As a result, aspect developers have to resort to low-level and complex pointcut descriptions that are error prone and hamper the understandability of aspect definitions. We analyze the issue of aspect reentrancy, illustrate how current languages fail to properly support it, and define a new linguistic construct to control aspect reentrancy. Considering aspect reentrancy from the start in the design of an aspect language simplifies the task of aspect programmers by raising the level of abstraction of aspect definitions.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3481

Authors: Alexandra Barros, Roberto Ierusalimschy

Abstract: Weak References constitute an elegant mechanism for an application to interact with its garbage collector. In most of its typical uses, weak references are used through weak tables (e.g., Java's WeakHashMap). However, most implementations of weak tables have a severe limitation: Cyclic references between keys and values in weak tables prevent the elements inside a cycle from being collected, even if they are no longer reachable from outside. This ends up bringing difficulties to the use of weak tables in some kinds of applications. In this work, we present our approach for overcoming this problem in the context of the Lua programming language. Our approach consists of an adaptation of the ephemerons mechanism to tables. We modified the garbage collector of the Lua virtual machine in order to offer support to this mechanism. With this adapted garbage collector we could verify the efficiency and effectiveness of the implementation in solving the problem of cycles on weak tables in Lua.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3431

Authors: Cecilia Manzino, Alberto Pardo

Abstract: Functional programs often combine separate parts of the program using intermediate data structures for communicating results. Programs so defined are easier to understand and maintain, but suffer from inefficiency problems due to the generation of those data structures. In response to this problematic, some program transformation techniques have been studied with the aim to eliminate the intermediate data structures that arise in function compositions. One of these techniques is known as shortcut fusion. This technique has usually been studied in the context of purely functional programs. In this work we propose an extension of shortcut fusion that is able to eliminate intermediate data structures generated in the presence of monadic effects. The extension to be presented can be uniformly defined for a wide class of data types and monads.

HTML

XML

PDF

DOI: 10.3217/jucs-014-20-3389

Authors: Didier Verna

Abstract: Implementing binary methods in traditional object-oriented languages isdifficult. Numerous problems arise regarding the relationship between types and classes in the context of inheritance, or the need for privileged access to the internal repre-sentation of objects. Most of these problems occur in the context of statically typed languages that lack multi-methods (polymorphism on multiple arguments). The pur-pose of this paper is twofold: to show why some of these problems are either non-issues, or easily solved in Common Lisp, and to demonstrate how the Common Lisp ObjectSystem (Clos) allows us to simply define, implement and enforce type-safe binary methods. These last considerations involve re-programming a binary method-specificobject system through the Clos Meta-Object Protocol (Mop).

HTML

XML

PDF

DOI: 10.3217/jucs-014-20-3370

Authors: Jim Newton, Christophe Rhodes

Abstract: We describe in this paper the implementation and use of custom specializers in two current dialects of Lisp: Skill and Common Lisp. We motivate the need for such specializers by appealing to clarity of expression, referring to experience in existing industrial applications. We discuss the implementation details of such user-defined specializers in both dialects of Lisp, detailing open problems with those implementations, and we sketch ideas for solving them.

HTML

XML

PDF

DOI: 10.3217/jucs-014-20-3358

Authors: Timothy Moore

Abstract: Presentation types are used in the CLIM interface library to tag graphical output with a type and establish an input type context in which the user may use the keyboard to type input, accepted by a parser associated with that presentation type, or click on the graphical representation of an object that has an appropriate presentation type. Presentation types are defined using a syntax reminiscent of the deftype syntax of Common Lisp; the input and output actions of the types, as well as aspects of their inheritance, are implemented using a system of generic functions and methods directly based on CLOS. The presentation type system is different enough from the Common Lisp type system that its types, generic functions and methods do not map directly to those of Common Lisp. We describe the presentation type implemention in McCLIM which uses the CLOS Metaobject Protocol to implement presentation type inheritance, method dispatch and method combination without implementing an entire parallel object system next to CLOS. Our implementation supports all types of method combination in the presentation methods, including user-defined method combination.

HTML

XML

PDF

DOI: 10.3217/jucs-014-20-3333

Authors: António Leitão

Abstract: UCL-GLORP is a Common Lisp implementation and extension of GLORP (Generic Lightweight Object-Relational Persistence), an Object-Relational Mapper for the Smalltalk language. UCL-GLORP is now a mature framework that largely extends GLORP and that takes advantage of some of Common Lisp unique features. This paper illustrates UCL-GLORP and discusses some of the challenges that we faced in order to find suitable replacements, in Common Lisp, for some of the more esoteric features of Smalltalk that were explored by GLORP.

HTML

XML

PDF

DOI: 10.3217/jucs-014-20-3307

Authors: Sebastián González, Kim Mens, Alfredo Cádiz

Abstract: In this paper we present AmOS, the Ambient Object System that underlies the Ambience programming language. AmOS implements a computation model that supports highly dynamic behaviour adaptation to changing contexts. Apart from being purely object-based, AmOS features first-class closures, multimethods and contexts. Dynamic method scoping through a subjective dispatch mechanism is at the heart of our approach. These features make of AmOS a very simple and elegant paradigm for context-oriented programming.

HTML

XML

PDF

DOI: 10.3217/jucs-013-08-1047

Authors: Christof Fetzer, Pascal Felber

Abstract: Exception handling is a powerful mechanisms for dealing with failures at runtime. It simplifies the development of robust programs by allowing the programmer to implement recovery actions and tolerate non-fatal errors. Yet, exception handling is difficult to get right! The complexity of correct exception handling is a major cause for incorrect exception handling. It is therefore important to reduce the complexity of writing exception handling code while, at the same time, making sure it is correct. Our approach is to use atomic blocks for exception handling combined with optional compensation actions.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0874

Authors: Carlos Camarão, Cristiano Vasconcellos, Lucília Figueiredo, João Nicola

Abstract: The type system of Haskell and some related systems are based on an open world approach for overloading. In an open world, the principal type of each overloaded symbol must be explicitly annotated (in Haskell, annotations occur in type class declarations) and a definition of an overloaded symbol is required to exist only when overloading is resolved. In a closed world, on the other hand, each principal type is determined according to the types of definitions that exist in the relevant context and, furthermore, overloading resolution for an expression considers only the context of the definition of its constituent symbols. In this paper we formally characterize open and closed worlds, and discuss their relative advantages. We present a type system that supports both approaches together, and compare the defined system with Haskell type classes extended with multi-parameter type classes and functional dependencies. We show in particular that functional dependencies are not necessary in order to support multi-parameter type classes, and present an alternative route.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0806

Authors: Carlos Henrique Q. Forster

Abstract: The spreadsheet metaphor has, over the years, proved itself valuable for the definition and use of computations by non-programmers. However, the computation model adopted in commercial spreadsheets is still limited to non-recursive computations and lacks abstraction mechanisms that would provide modularization and better reuse (beyond copy and paste). We investigate these problems by identifying a minimal set of requirements for recursive computations, designing a spreadsheet-based language with an abstraction definition mechanism, prototyping an interpreter and evaluating it with examples.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0786

Authors: Thaís Batista, Maurício Vieira

Abstract: AspectLua is a Lua-based dynamic aspect-oriented language that follows the original AspectJ concepts. It suffers from the same problem of AspectJ-like languages with regard to limitations in terms of aspect reusability, modularity and heterogeneous interaction. In this paper we propose RE-AspectLua, a new version of AspectLua that combines aspect interfaces with abstract joinpoints and the use of a connection language, the Lua language, to instantiate, at application composition time, the abstract joinpoints. Thus, the connection language defines the composition of reusable aspects with base code. Using these concepts RE-AspectLua intends to break away from the syntactically manifest coding of aspects in which joinpoints are hard-coded into aspects, thereby promoting general reusability and the heterogeneous composition of an aspect with different base codes. In order to illustrate RE-AspectLua concepts we present two case studies.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0682

Authors: Frederico Jr., Ricardo Lima, Marcio Cornelio, Sergio Soares, Paulo Maciel, Raimundo Barreto, Eduardo Tavares

Abstract: Non-functional requirements such as performance, program size, and energy consumption significantly affect the quality of software systems. Small devices like PDAs and mobile phones have little memory, slow processors, and energy constraints. The C programming language has been the choice of many programmers when developing application for small devices. On the other hand, the need for functional software correctness has derived several specification languages that adopt the Design by Contract (DBC) technique. In this work we propose a specification language for C, called CML (C Modeling Language), focused on non-functional requirements. CML is inspired on the Design By Contract technique. An additional contribution is a verification tool for hard real-time systems. The tool is the first application developed for CML. The practical usage of CML is presented through a case study, which is a real application for a vehicle monitoring system.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1500

Authors: Maryam Bavarian, Veronica Dahl

Abstract: The need for processing biological information is rapidly growing, owing to the masses of new information in digital form being produced at this time. Old methodologies for processing it can no longer keep up with this rate of growth. The methods of Artificial Intelligence (AI) in general and of language processing in particular can offer much towards solving this problem. However, interdisciplinary research between language processing and molecular biology is not yet widespread, partly because of the effort needed for each specialist to understand the other one's jargon. We argue that by looking at the problems of molecular biology from a language processing perspective, and using constraint based logic methodologies we can shorten the gap and make interdisciplinary collaborations more effective. We shall discuss several sequence analysis problems in terms of constraint based formalisms such Concept Formation Rules, Constraint Handling Rules (CHR) and their grammatical counterpart, CHRG. We postulate that genetic structure analysis can also benefit from these methods, for instance to reconstruct from a given RNA secondary structure, a nucleotide sequence that folds into it. Our proposed methodologies lend direct executability to high level descriptions of the problems at hand and thus contribute to rapid while efficient prototyping.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1466

Authors: Antonio J. Fernández Leiva, Patricia Hill

Abstract: Abstract This paper presents a branching schema for the solving of a wide range of interval constraint satisfaction problems defined on any domain of computation, finite or infinite, provided the domain forms a lattice. After a formal definition of the branching schema, useful and interesting properties, satisfied by all instances of the schema, are presented. Examples are then used to illustrate how a range of operational behaviors can be modelled by means of different schema instantiations. It is shown how the operational procedures of many constraint systems (including cooperative systems) can be viewed as instances of this branching schema. Basic directives to adapt this schema to solving constraint optimization problems are also provided.

HTML

XML

PDF

DOI: 10.3217/jucs-012-09-1177

Authors: Miklós Espák

Abstract: Imperative programming languages (such as Java) are the most widespread programming languages recently. Besides being quite easy to get familiar with them, they are also perfectly suitable for business software development. Although the productivity of imperative languages is much acclaimed, some problems are much easier to solve in a logical language. The paper introduces a Java language extension called Japlo, which fits the Prolog language constructs into Java harmonically. Blurring the borders between the representatives of these two paradigms, the author aims at making the logical programming tools more easily available for Java programmers. Japlo does not only provide a foreign language interface to Prolog programs, but you can write Prolog rules within the language relying on some basic concepts (static typing, expression orientation) and the grammatic structure of Java.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0868

Authors: André Rauber Du Bois, Phil Trinder, Hans-Wolfgang Loidl

Abstract: In a mobile language, computations can move between locations in a network to better utilise resources, e.g., as in a computational GRID. Mobile Haskell, or mHaskell, is a small extension of Concurrent Haskell that enables the construction of distributed mobile software by introducing higher order communication channels called Moble Channels (MChannels). mHaskell only provides weak mobility, i.e. the ability to start new computations on remote locations. This paper shows how strong mobility, i.e. the ability to migrate running threads between locations, can be implemented in a language like mHaskell with weak mobility, higher-order channels and first-class continuations. Using Haskell's high level features, such as higher-order functions, type classes and support for monadic programming, strong mobility is achieved without any changes to the runtime system, or built-in support for continuations. Strong mobility is illustrated with examples and a mobile agent case study.

HTML

XML

PDF

DOI: 10.3217/jucs-011-10-1645

Authors: Fei Cao, Barrett Bryant, Rajeev Raje, Andrew Olson, Mikhail Auguston, Wei Zhao, Carol Burt

Abstract: Component-based software composition offers a development approach with reduced time-to-market and cost while achieving enhanced productivity, quality and maintainability. Existent work on the composition paradigm focuses on static composition, which is not sufficient in a distributed environment, in which both constituent components and the assembled distributed system are subject to dynamic adaptation. This paper presents two types of dynamic composition for distributed components: assertive and autonomous over a .NET based Web Services environment. Three case studies are provided to illustrate the use of assertive and autonomous composition.

HTML

XML

PDF

DOI: 10.3217/jucs-011-10-1613

Authors: Alexandre Bergel, Stéphane Ducasse, Oscar Nierstrasz

Abstract: Each object­oriented programming language proposes various grouping mechanisms to bundle interacting classes (i.e., packages, modules, selector namespaces, etc). To understand this diversity and to compare the different approaches, a common foundation is needed. In this paper we present a simple module calculus consisting of a small set of operators over environments and modules. Using these operators, we are then able to specify a set of module combinators that capture the semantics of Java packages, C# namespaces, Ruby modules, selector namespaces, gbeta classes, classboxes, MZScheme units, and MixJuice modules. We develop a simple taxonomy of module systems, and show how particular combinations of module operators help us to draw sharp distinctions between classes of module systems that share similar characteristics.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1255

Authors: Monique Monteiro, Mauro Araújo, Rafael Borges, André Santos

Abstract: In this work, we propose a compilation strategy for non­strict functional languages targeting the Microsoft .NET Platform, a multilanguage platform which provides a large number of services to aid current software development. This strategy is based on the push/enter execution model, enables fast function calling mechanisms whenever possible and males use of new features present in .NET Framework, such as delegates and tail calls. Our case study was the compilation of the Haskell language, a standardized and well known non­strict functional language. Our main contribution is the construction of an environment for the testing of different compilation techniques for functional languages targeting .NET.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1234

Authors: Andrè Rauber Du Bois, Phil Trinder, Hans-Wolfgang Loidl

Abstract: We provide a complete description of mHaskell, a new mobile programming language that extends the Haskell functional language. We describe new stateful mobility primitives that use higher-order channels, giving their operational semantics and an implementation outline. We show how medium-level coordination abstractions can be constructed using monadic composition of the mobility primitives. We briefly outline how high-level mobile coordination abstractions, or mobility skeletons, can be defined using the lower-level abstractions. The use of all three abstractions is demonstrated with examples and a new case study: a distributed stateless web server where a thread farm skeleton is used to distribute work to remote locations.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1198

Authors: Marcus Leal, Roberto Ierusalimschy

Abstract: Automatic finalization is a common but inherently complex language facility that makes the garbage collection process semantically visible to client programs. With finalizers, memory management becomes more flexible, and garbage collectors can be used to recycle other resources in addition to memory. Formal language models usually ignore garbage collection, and therefore are unable to properly describe finalization. In this paper we use an operational approach to develop a new abstract model that explicitly represents memory management actions in a garbage­collected programming language based on the λ­calculus. We formally state and prove several important properties related to memory management, and employ the model to describe and explore a semantics for finalizers.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1177

Authors: Néélio Cacho, Thaís Batista, Fabrício Fernandes

Abstract: In this paper we describe AspectLua - a dynamic aspect-oriented language based on Lua. It relies on a meta-object protocol, LuaMOP, which unifies the introspective and reflective mechanisms provided by Lua and handles the weaving process. In order to improve support for dynamicity, AspectLua allows the association of aspects with undeclared elements of the application code (virtual join points). In addition, it provides an automatic support for managing aspects execution order.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1159

Authors: Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes

Abstract: We discuss the main novelties of the implementation of Lua 5.0: its register-based virtual machine, the new algorithm for optimizing tables used as arrays, the implementation of closures, and the addition of coroutines.

HTML

XML

PDF

DOI: 10.3217/jucs-011-07-1117

Authors: Peter Mosses

Abstract: Most approaches to formal semantics are based on the assumption that all the constructs of a language are defined together. The details of the definition of each construct can (and usually do) depend on which other constructs are included in the given language. This limits reuse of definitions of common constructs. With the more constructive approach proposed here, the semantics of each basic abstract programming construct is defined separately and independently. The semantics of a full language is obtained by translating its constructs into the basic abstract constructs, whose definitions are thus reused verbatim. The frameworks of Modular SOS and Action Semantics can both be used in conjunction with the proposed approach. Some illustrations are given.

HTML

XML

PDF

DOI: 10.3217/jucs-011-04-0452

Authors: Norbert Gronau, Claudia Müller, Roman Korf

Abstract: Existing approaches in the area of knowledge-intensive processes focus on integrated knowledge and process management systems, the support of processes with KM systems, or the analysis of knowledge-intensive activities. For capturing knowledge-intensive business processes well known and established methods do not meet the requirements of a comprehensive and integrated approach of process-oriented knowledge management. These approaches are not able to visualise the decisions, actions and measures which are causing the sequence of the processes in an adequate manner. Parallel to conventional processes knowledge-intensive processes exist. These processes are based on conversions of knowledge within these processes. To fill these gaps in modelling knowledge-intensive business processes the Knowledge Modelling and Description Language (KMDL) got developed. The KMDL is able to represent the development, use, offer and demand of knowledge along business processes. Further it is possible to show the existing knowledge conversions which take place additionally to the normal business processes. The KMDL can be used to formalise knowledge-intensive processes with a focus on certain knowledge-specific characteristics and to identify process improvements in these processes. The KMDL modelling tool K-Modeler is introduced for a computer-aided modelling and analysing. The technical framework and the most important functionalities to support the analysis of the captured processes are introduced in the following contribution.

HTML

XML

PDF

DOI: 10.3217/jucs-010-09-1302

Authors: José Sierra, Alfredo Fernández-Valmayor, Baltasar Fernández-Manjón, Antonio Navarro

Abstract: This paper proposes a document oriented paradigm to the development of content-intensive, document-based applications (e.g. educational and hypermedia applications, and knowledge based systems). According to this paradigm, the main aspects of this kind of applications can be described by means of documents. Afterwards, these documents are marked up using descriptive domain-specific markup languages and applications are produced by the automatic processing of these marked documents. We have used this paradigm to improve the maintenance and portability of content-intensive educational and hypermedia applications. ADDS (Approach to Document-based Development of Software) is an approach to software development based on the document oriented paradigm. A key feature of ADDS is that formulation of domain-specific markup languages is a dynamic and eminently pragmatic activity, and markup languages evolve according to the authoring needs of the different participants in the development process (domain experts and developers). The evolutionary nature of markup languages in ADDS leads to OADDS (Operationalization in ADDS), the proposed operationalization model for the incremental development of modular markup language processors. Finally, the document-oriented paradigm can also be applied in the construction of OADDS processors that are also described using marked documents. This paper presents our ADDS approach, including the operationalization model and its implementation as an object-oriented framework. The application of our document-oriented paradigm to the construction of OADDS processors is also presented.

HTML

XML

PDF

DOI: 10.3217/jucs-010-09-1272

Authors: James Power, David Sinclair

Abstract: In this paper we develop a formal specification of aspects of the Forth programming language. We describe the operation of the Forth compiler as it translates XSForth control words, dealing in particular with the interpretation of immediate words during compilation. Our goal here is to provide a basis for the study of safety properties of embedded systems, many of which are constructed using Forth or Forth-like languages. To this end we construct a model of the Forth compiler in the -calculus, and have simulated its execution by animating this model using the Pict programming language.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0910

Authors: Ana De Moura, Noemi Rodriguez, Roberto Ierusalimschy

Abstract: After a period of oblivion, a renewal of interest in coroutines is being observed. However, most current implementations of coroutine mechanisms are restricted, and motivated by particular uses. The convenience of providing true coroutines as a general control abstraction is disregarded. This paper presents and discusses the coroutine facilities provided by the language Lua, a full implementation of the concept of asymmetric coroutines. It also shows that this powerful construct supports easy and succint implementations of useful control behaviors.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0892

Authors: Fabio Mascarenhas, Roberto Ierusalimschy

Abstract: We present LuaInterface in this paper, a library for scripting the .NET CLR with Lua. The .NET Common Language Runtime (CLR) aims to provide interoperability among objects written in several different languages. LuaInterface gives Lua the capabilities of a full CLS consumer. The Common Language Specification (CLS) is a subset of the CLR specification, with rules for language interoperability, and CLS consumers are languages that can use CLS_compliant libraries. LuaInterface lets Lua scripts instantiate and use CLR objects, and even create new CLR types. CLR applications may also use LuaInterface to embed a Lua interpreter, using Lua scripts to extend the application. LuaInterface is implemented as a bridge between the Lua interpreter and the CLR. The implementation required no changes to the interpreter, and the level of integration is the same that a Lua compiler would have.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0872

Authors: Ademir De Oliveira, Thiago Braga, Marcelo Maia, Roberto Bigonha

Abstract: MetaJ is a programming environment that supports metaprogramming in the Java language. The environment is designed to allow extensions via plug-ins which permit the user to manipulate programs written in different languages. This facilities concern only syntactic aspects. Semantics aspects are language-dependent and are not addressed here, but could be tackled with other tools, which could even be layered on the top of MetaJ. Accessing patterns by example inside ordinary Java programs is a major feature of MetaJ programming. This paper presents a conceptual description of the environment, implementation details and three applications on analysis, restructuring and generation of programs.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0843

Authors: Fernando Filho, Cecília Mary F. Rubira

Abstract: Exception handling is a very popular technique for incorporating fault tolerance into software systems. However, its use for structuring concurrent, distributed systems is hindered by the fact that the exception handling models of many mainstream object-oriented programming languages are sequential. In this paper we present an aspect-based framework for incorporating concurrent exception handling in Java programs. The framework has been implemented in AspectJ, a general purpose aspect-oriented extension to Java. Our main contribution is to show that AspectJ is useful for implementing the concerns related to concurrent exception handling and to provide a useful tool to developers of distributed, concurrent fault-tolerant applications.

HTML

XML

PDF

DOI: 10.3217/jucs-010-07-0824

Authors: Fernando Magno Quintão Pereira, Marco Valente, Wagner Pires, Roberto Bigonha, Mariza Andrade Silva Bigonha

Abstract: Conventional object oriented middleware platforms rely on the notion of remote interfaces to describe distributed services. This notation is very similar to the one currently used in centralized systems, which increases the productivity of programming. This paper is founded in the observation that remote interfaces foster a programming model that ignores the differences between local and remote interactions. This can result in distributed applications with poor performance, that are not robust to failures, and that can not scale beyond local networks. Therefore, we propose that remote interfaces should be accompanied by the specification of tactics that deal with typical events in distributed computing, such as concurrency, partial failures and high latencies. The paper proposes a tactics definition language and describes the implementation of a middleware system that supports this language.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0956

Authors: Franklin Ramalho, Jacques Robin, Roberto Barros

Abstract: In this paper, we present XOCL, an XML-based language to represent OCL (Object Constraint Language) constraints in UML models. XOCL was designed in two steps from the UML meta-model and OCL EBNF grammar published by OMG: (1) construction of a simple OCL meta-model and (2) derivation of an XML Schema for this meta-model. XOCL applications include full interoperability among UML modelling tools as well as finely grained structured input for automatic behavioral code generation and model checking.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0873

Authors: Cristiano Vasconcellos, Lucília Figueiredo, Carlos Camarão

Abstract: This paper describes a practical type inference algorithm for typing poly-morphic and possibly mutually recursive definitions, using Haskell to provide a high-level implementation of the algorithm.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0851

Authors: Hongwei Xi

Abstract: The mechanism for declaring datatypes to model data structures in programming languages such as Standard ML and Haskell can offer both convenience in programming and clarity in code. With the introduction of dependent datatypes in DML, the programmer can model data structures with more accuracy, thus capturing more program invariants. In this paper, we study some practical aspects of dependent datatypes that affect both type-checking and compiling pattern matching. The results, which have already been tested, demonstrate that dependent datatype can not only o#er various programming benefits but also lead to performance gains, yielding a concrete case where safer programs run faster.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0776

Authors: Francisco Heron de Carvalho Júnior, Rafael Lins

Abstract: This paper presents the final result of the designing of a new specification for the Haskell# Language, including new features to increase its expressiveness, but without losing either efficiency or obedience to its original premisses.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0761

Authors: Wendell Taveira, Marco Valente, Mariza Andrade Silva Bigonha

Abstract: Java RMI is the computational model used to develop distributed systems in the Java language. Although widely used in the construction of distributed systems, the use of Java RMI is limited because this middleware does not allow asynchronous method invocations. This paper presents FlexRMI, a Java based system that supports asynchronous invocations of remote methods. FlexRMI is completely implemented in Java, making use of the reflection and dynamic proxy facilities of this language. The implementation is also compatible with standard Java RMI distributed systems.

HTML

XML

PDF

DOI: 10.3217/jucs-009-01-0002

Authors: Richard Banach, Farhad Arbab, George Papadopoulos, John R. W. Glauert

Abstract: The drawbacks of programming coordination activities directly within the applications software that needs them are briefly reviewed. Coordination programming helps to separate concerns, making complex coordination protocols into standalone entities, permitting separate development, verification, maintenance, and reuse. The IWIM coordination model is described, and a formal automata theoretic version of the model is developed, capturing the essentials of the framework in a fibration based approach. Specifically, families of worker automata have their communication governed by a state of a manager automaton, whose transitions correspond to reconfigurations. To capture the generality of processes in IWIM systems, the construction is generalised so that process automata can display both manager and worker traits. The relationship with other formalisations of the IWIM conception of the coordination principle is explored.

HTML

XML

PDF

DOI: 10.3217/jucs-007-11-1068

Authors: Joachim Schmid

Abstract: Abstract State Machines (ASMs) have been widely used to specify soft-ware and hardware systems. Only a few of these specifications are executable, although there are several interpreters and some compilers. This paper introduces a compilation scheme to transform an ASM specification in the syntax of the ASM-Workbench into C++. In particular, we transform algebraic types, pattern matching, functional expressions, dynamic functions, and simultaneous updates to C++ code. The main aim of this compilation scheme is to preserve the specification structure in the generated code without generating inefficient code. The implemented compiler was used successfully in the industrial FALKO application at Siemens Corporate Technology.

HTML

XML

PDF

DOI: 10.3217/jucs-007-11-0917

Authors: Yuri Gurevich, Nikolai Tillmann

Abstract: The partial update problem for parallel abstract state machines has manifested itself in the cases of counters, sets and maps. We propose a solution of the problem that lends itself to an efficient implementation and covers the three cases mentioned above. There are other cases of the problem that require a more general framework.

HTML

XML

PDF

DOI: 10.3217/jucs-003-12-1382

Authors: Uwe Glaesser, Rene Karges

Abstract: Based on the ITU-T Recommendation Z.100 [27]---also known as SDL-92--- we define a formal semantic model of the dynamic properties of Basic SDL in terms of an abstract SDL machine. More precisely, we use the concept of multi-agent realtime ASM [17] as a semantic platform on top of which we construct our mathematical description. The resulting interpretation model is not only mathematically precise but also reflects the common understanding of SDL in a direct and intuitive manner; it provides a concise and understandable representation of the complete dynamic semantics of Basic SDL. Moreover, the model can easily be extended and modified---a particularly important issue for an evolving technical standard. In this article, we consider all relevant aspects concerning the behavior of channels, processes and timers with respect to signal transfer operations and timer operations. The model we obtain is intended as a basis for formal documentation as well as for executable high-level SDL specifications.

HTML

XML

PDF

DOI: 10.3217/jucs-003-05-0443

Authors: Philipp Kutter, Alfonso Pierantonio

Abstract: This paper presents the formal specification of the programming language Oberon. Using Montages we give a description of syntax, static, and dynamic semantics of all constructs of the language. The specification is arranged in five refinement steps, each of them results in a working sub-language of Oberon. The compactness and readability of the specification make us believe that it can be used for a reference manual.

HTML

XML

PDF

DOI: 10.3217/jucs-003-01-0042

Authors: D. Skillicorn

Abstract: Document archives contain large amounts of data to which sophisticated queries are applied. The size of archives and the complexity of evaluating queries makes the use of parallelism attractive. The use of semantically-based markup such as SGML makes it possible to represent documents and document archives as data types. We present a theory of trees and tree homomorphisms, modelling structured text archives and operations on them, from which it can be seen that: many apparently unrelated tree operations are homomorphisms, homomorphisms can be described in a simple parameterised way that gives standard sequential and parallel implementations for them, and certain special classes of homomorphisms have parallel implementations of practical importance. In particular, we develop an algorithm for path expression search, a novel powerful query facility for structured text, taking time logarithmic in the text size. This algorithm is the first example of a new algorithm discovered using homomorphic skeletons over data types.

HTML

XML

PDF