DOI: 10.3897/jucs.169476

Authors: Jefferson Martins, Rodrigo Andrade, Luis F. Alves Pereira

Abstract: Skilled software developers play a crucial role in creating energy-efficient code, contributing to the reduction of carbon emissions and promoting sustainable computing practices. In parallel, Large Language Models (LLMs) have recently emerged as powerful programming assistants, providing support for developers in complex coding tasks. In this context, this study investigates the ability of LLMs to generate computationally efficient implementations of classic algorithms - such as Heap Sort and Binary Search - across different programming languages, with a primary focus on optimizing energy consumption, memory usage, and execution time. Our results show that, in most cases, different LLMs are able to generate these algorithm implementations correctly. Furthermore, in the majority of the evaluated scenarios, LLM-generated code demonstrates superior performance over human-written algorithm code with regard to energy consumption, memory efficiency, and execution time.

HTML

PDF

DOI: 10.3897/jucs.150681

Authors: Ashish Ranjan Mishra, Rakesh Kumar, Rajkumar Saini

Abstract: Ensuring secure and reliable person authentication is a critical challenge in modern security systems. Traditional biometric systems relying on physiological traits like fingerprints, iris, and facial recognition often suffer from spoofing vulnerabilities. In contrast, electroencephalogram (EEG) signals, characterized by unique temporal and cognitive patterns, provide a robust authentication mechanism. This paper introduces DeepV-Net, a multimodal fully convolutional neural network that leverages both EEG signals and dynamic handwritten signature data acquired from Wacom devices. The proposed model integrates spatial and temporal features of EEG signals with distinctive movement-based signature patterns through an end-to-end multimodal fusion strategy. Experimental evaluations on benchmark datasets demonstrate that DeepV-Net outperforms unimodal approaches and state-of-the-art authentication methods, achieving a training accuracy of 99.1% and a validation accuracy of 93.3%. These findings highlight the complementary nature of EEG and signature modalities, paving the way for more secure and efficient biometric authentication systems.

HTML

PDF

DOI: 10.3897/jucs.107050

Authors: Josival Silva, Nelson Rosa, Fernando Aires

Abstract: Smart home devices are vulnerable to attacks that put their users’ security at risk. Vulnerabilities are discovered very frequently and can expose these devices through unsecured services. Meanwhile, the lack of standardisation in upgrade methods makes smart homes a potentially vulnerable environment. Furthermore, many manufacturers release their products and then abandon them, refusing to support security updates. As a result, security updates are needed to deal with the emergence of new attacks. There are several proposals to promote security in smart homes. However, there are rare solutions where changes for security purposes occur with little or no human intervention. This paper presents UP-Home, a self-adaptive solution that manages the security of smart homes. UP-Home aims to ensure that smart home devices meet the security requirements set by industry standards. The solution can continually identify and mitigate smart home security vulnerabilities. With autonomous computing techniques, UP-Home seeks to ensure the self-protection of devices and, consequently, the entire smart home. With the UP-Home evalu-ation, it was possible to notice significant improvements in the security of the smart home without any human intervention.

HTML

PDF

DOI: 10.3897/jucs.96347

Authors: Ricardo Caceffo, Jacques Wainer, Guilherme Gama, Islene Garcia, Rodolfo Azevedo

Abstract: Perceptual Learning Modules (PLMs) is a variation of Perceptual Learning based on multiple-choice questionnaires. There exists successful research of the use of PLMs in math and flight training. The possibility of designing and adopting PLMs in Introductory Programming Courses (CS1) is still an open area of study. The goal of this study is to test whether students that received a PLM training on recognising segments of programs will perform better at writing programs. Two PLM interventions were administered to students. The first intervention was a nonrandom controlled experiment, in which students opted to answer the PLM questionnaire (N=40), while the control group consisted of students that did not answer it (N=629). The second intervention was a randomized controlled experiment with a placebo, in which students were randomly assigned to perform either the PLM questionnaire (N=51) or another a placebo activity (N=51). The different forms of analysis of the first experiment results yielded Cohen’s d ranging from 0.23 to 0.34 in favor of the PLM intervention. For the second experiment, the effect size was d = -0.11 against the PLM intervention, but the two results were significant. We believe that the cautious conclusion is that there is a null effect in using a PLM activity as part of a CS1 course. The paper is also of interest because of the methodological decisions and techniques used.

HTML

XML

PDF

DOI: 10.3897/jucs.72205

Authors: Paul Leger, Hiroaki Fukuda, Ismael Figueroa

Abstract: JavaScript is one of the main programming languages to develop highly rich responsive and interactive Web applications. In these kinds of applications, the use of asynchronous operations that execute callbacks is crucial. However, the dependency among nested callbacks, known as callback hell, can make it difficult to understand and maintain them, which will eventually mix concerns. Unfortunately, current solutions for JavaScript do not fully address the aforementioned issue. This paper presents Sync/cc, a JavaScript package that works on modern browsers. This package is a proof-of-concept that uses continuations and aspects that allow developers to write event handlers that need nested callbacks in a synchronous style, preventing callback hell. Unlike current solutions, Sync/cc is modular, succinct, and customizable because it does not require ad-hoc and scattered constructs, code refactoring, or adding ad-hoc implementations such as state machines. In practice, our proposal uses a) continuations to only suspend the current handler execution until the asynchronous operation is resolved, and b) aspects to apply continuations in a non-intrusive way. We test Sync/cc with a management information system that administers courses at a university in Chile.

HTML

XML

PDF

DOI: 10.3897/jucs.71831

Authors: Nermin Kajtazovic, Peter Hödl, Leo Happ Botler

Abstract: Coexistence of software components and functions of different criticality in a single computing platform has challenged the safety community for the past two decades. Despite efforts that have been made so far, dealing with mixed-criticality has still left some room for improvements. One particular concern here is that partitioning of hardware and software resources with regard to criticality (safety related, non-safety related) has direct implications on how safety measures need to be realised. For example, a self-test that must meet certain diagnostic coverage for the microcontroller core by inspecting its instructions, needs to cover only those instructions which are able to affect a safety function. Available software mechanisms and tools are to a certain extent still unable to deal with such a fine-grained selection of resources. In this work, we introduce a compiler extension and language support which enable accurate selection of data based on their criticality. The compiler extension serves to establish detailed traceability between the software code and its representation in runtime memory. With the language support, the individual data elements can be classified based on the desired safety integrity level. As a result, safety measures that operate on data (e.g. Abraham test for SRAM can achieve better coverage. The method has been evaluated and applied to industrial safety controllers. We provide here relevant performance figures and discuss possible applications of the method in other fields.

HTML

XML

PDF

DOI: 10.3897/jucs.2020.051

Authors: Robin Horst, Ramtin Naraghi-Taghi-Off, Linda Rau, Ralf Dorner

Abstract: Bite-sized learning is a current educational trend in which educators divide content into relatively small, easily comprehensible chunks, called nuggets. In this paper, we introduce an authoring toolkit that relies on VR implementation of nuggets and show that a nugget-based approach is also facilitating the authoring of VR learning content. In particular, we present Immersive Nugget Tiles (IN-Tiles), a novel authoring toolkit aimed at authors who are not experts in VR. With IN-Tiles, manipulating VR nuggets and authoring VR learning content can be directly accomplished within a virtual environment allowing authors to immediately experience the results of their authoring efforts in VR. We discuss the underlying concepts of IN-Tiles, specifically how to visualize VR nuggets in a virtual environment and how to present affordances that support authoring and manipulating VR nuggets. We report the results of a user study where we evaluated the IN-Tiles toolkit and compared it to a conventional 2D authoring environment that also relies on component-based VR. The results support the hypothesis that nugget-based immersive authoring tools are suitable to create bitesized VR applications successfully and that authoring directly in VR has an added value particularly for authors who are no IT specialists.

HTML

XML

PDF

DOI: 10.3897/jucs.2020.013

Authors: Huimin Fu, Yang Xu, Shuwei Chen, Jun Liu

Abstract: Stochastic local search (SLS) algorithms are well known for their ability to efficiently find models of random instances of the Boolean satisfiability (SAT) problems. One of the most famous SLS algorithms for SAT is called WalkSAT, which has wide influence and performs well on most of random 3-SAT instances. However, the performance of WalkSAT lags far behind on random 3-SAT instances equal to or greater than the phase transition ratio. Motivated by this limitation, in the present work, firstly an allocation strategy is introduced and utilized in WalkSAT to determine the initial assignment, leading to a new algorithm called WalkSATvav. The experimental results show that WalkSATvav significantly outperforms the state-of-the-art SLS solvers on random 3-SAT instances at the phase transition for SAT Competition 2017. However, WalkSATvav cannot rival its competitors on random 3-SAT instances greater than the phase transition ratio. Accordingly, WalkSATvav is further improved for such instances by utilizing a combination of an improved genetic algorithm and an improved ant colony algorithm, which complement each other in guiding the search direction. The resulting algorithm, called WalkSATga, is far better than WalkSAT and significantly outperforms some previous known SLS solvers on random 3-SAT instances greater than the phase transition ratio from SAT Competition 2017. Finally, a new SAT solver called WalkSATlg, which combines WalkSATvav and WalkSATga, is proposed, which is competitive with the winner of random satisfiable category of SAT competition 2017 on random 3-SAT problem.

HTML

XML

PDF

DOI: 10.3217/jucs-025-04-0390

Authors: Matias Micheletto, Rodrigo Santos, Javier Orozco

Abstract: In this paper we present meta-heuristics to solve the energy aware reward based scheduling of real-time tasks with mandatory and optional parts in homogeneous multi-core processors. The problem is NP-Hard. An objective function to maximize the performance of the system considering the execution of optional parts, the benefits of slowing down the processor and a penalty for changing the operation power-mode is introduced together with a set of constraints that guarantee the real-time performance of the system. The meta-heuristics are the bio-inspired methods Particle Swarm Optimization and Genetic Algorithm. Experiments are made to evaluate the proposed algorithms using a set of synthetic systems of tasks. As these have been used previously with an Integer Lineal Programming approach, the results are compared and show that the solutions obtained with bio-inspired methods are within the Pareto frontier and obtained in less time. Finally, precedence related tasks systems are analyzed and the meta-heuristics proposed are extended to solve also this kind of systems. The evaluation is made by solving a traditional example of the real-time precedence related tasks systems on multiprocessors. The solutions obtained through the methods proposed in this paper are good and show that the methods are competitive. In all cases, the solutions are similar to the ones provided by other methods but obtained in less time and with fewer iterations.

HTML

XML

PDF

DOI: 10.3217/jucs-024-11-1627

Authors: Laura Po, Davide Malvezzi

Abstract: The Linked Open Data (LOD) Cloud has more than tripled its sources in just six years (from 295 sources in 2011 to 1163 datasets in 2017). The actual Web of Data contains more then 150 Billions of triples. We are assisting at a staggering growth in the production and consumption of LOD and the generation of increasingly large datasets. In this scenario, providing researchers, domain experts, but also businessmen and citizens with visual representations and intuitive interactions can significantly aid the exploration and understanding of the domains and knowledge represented by Linked Data. Various tools and web applications have been developed to enable the navigation, and browsing of the Web of Data. However, these tools lack in producing high level representations for large datasets, and in supporting users in the exploration and querying of these big sources. Following this trend, we devised a new method and a tool called H-BOLD (High level visualizations on Big Open Linked Data). H-BOLD enables the exploratory search and multilevel analysis of Linked Open Data. It offers different levels of abstraction on Big Linked Data. Through the user interaction and the dynamic adaptation of the graph representing the dataset, it will be possible to perform an effective exploration of the dataset, starting from a set of few classes and adding new ones. Performance and portability of H-BOLD have been evaluated on the SPARQL endpoint listed on SPARQL ENDPOINT STATUS. The effectiveness of H-BOLD as a visualization tool is described through a user study.

HTML

XML

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-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-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-022-08-1072

Authors: Hiroaki Fukuda, Paul Leger, Keita Namiki

Abstract: A Wireless Sensor Network (WSN) is typically deployed in a location in which no electrical source is provided, meaning that sufficient battery life is crucial. Applications for WSNs require implementations of complex operations such as network administration. To simplify the development of these applications, several mobile agent middleware solutions have been proposed. Applications for these middleware frameworks are executed by communication among agents; therefore, a common operation is to look up agents. Because existing proposals do not have much technical support for an efficient approach to look up agents, every lookup consumes a significant amount of battery power and time. In addition, current approaches can fail in their lookup operations if the target agent moves during a lookup operation. This paper proposes Chord for Mobile agent on Sensor Network (CMSN), an efficient and effective lookup for mobile agent middleware. CMSN is inspired by Chord for Sensor Networks (CSN), which introduces hierarchical ring structures and a distributed hash table algorithm to improve lookup performance. Unfortunately, CSN cannot be applied to mobile agent middleware solutions because CSN always requires a base station and assumes no agent migration between nodes. Unlikely CSN, CMSN is designed for an environment where agents can freely move between nodes without dependency on a special node such as a base station. In addition, CMSN leverages a feature where the location of a node is stationary in order to improve lookup performance with simplified algorithms. We evaluate and compare CMSN in terms of performance, effective lookups, and battery consumption.

HTML

XML

PDF

DOI: 10.3217/jucs-022-06-0874

Authors: Piotr Jędrzejowicz, Aleksander Skakovski

Abstract: Differential evolution (DE) is a stochastic global optimization method, that has been under continuous development during the past two decades. It has been recognized that preserving the diversification of population can significantly improve the performance of DE. Although, several results and approaches to population diversification have been proposed, it seems that this issue still has a potential for development. In this paper we have studied experimentally the possibility of increasing the performance of DE. Our investigation aims at identifying how the performance of DE depends on such factors as population diversity, size and number of fitness function evaluations carried out by DE to yield a solution. In our experiments we diversified the population in an intensive manner using the proposed decloning procedure carried out in cycles, and also through increasing the population size. The choice of how to preserve the diversification may depend on restrictions imposed on the population size, response time, and the quality of solutions that should be met by a specific implementation of the algorithm. The obtained results allowed us to propose a performance improvement policy that might noteworthy improve both the efficacy and response time of the algorithm. The discrete-continuous scheduling with continuous resource discretisation was used as the test problem.

HTML

XML

PDF

DOI: 10.3217/jucs-022-01-0124

Authors: Dilek Karahoca, Adem Karahoca, Ayça Kurnaz

Abstract: This study aims to investigate certain communication dimensions to assess the impact of Computer Mediated Communication (CMC) tendencies of students on ubiquitous environments. Communication dimensions were determined as message content, message interaction, semantic of message, emotional situation, and security. Message content was used as a determiner indicator to measure the effectiveness of communication methods in ubiquitous environments. The effects on the inclination to communicate in ubiquitous learning environments are explained in detail with Partial Least Squares Structural Equation Modeling (PLS-SEM). Message interaction, semantic of message, and security all have a great impact on the adoption of message content; therefore, they promote students' engagement through ubiquitous learning. According to the correlation values, we observed that the user is prone to participate in CMC if the message is meaningful, replied to immediately, sent from someone that looks familiar and sent to the right person.

HTML

XML

PDF

DOI: 10.3217/jucs-021-11-1405

Authors: Iaakov Exman, Juan Llorens, Anabel Fraga, Jose Alvarez-Rodríguez

Abstract: There has been a growing awareness of deep relations between software and knowledge. Software, from an efficiency oriented way to program computing machines, gradually converged to human oriented Runnable Knowledge. Apparently this has happened unintentionally, but knowledge is not incidental to software. The basic thesis: runnable knowledge is the essence of abstract software. A knowledge distillation procedure is offered as a constructive feasibility proof of the thesis. A formal basis is given for these notions. Runnable knowledge is substantiated in the association of semantic structural models (like ontologies) with formal behavioral models (like UML statecharts). Meaning functions are defined for ontologies in terms of concept densities. Examples are provided to concretely clarify the meaning and implications of knowledge runnability. The paper concludes with the runnable knowledge convergence point: SKYWare, a new term designating the domain in which content meaning is completely independent of any underlying machine.

HTML

XML

PDF

DOI: 10.3217/jucs-020-09-1351

Authors: Nuria Losada, María Martín, Gabriel Rodríguez, Patricia González

Abstract: Despite the increasing popularity of shared-memory systems, there is a lack of tools for providing fault tolerance support to shared-memory applications. CPPC (ComPiler for Portable Checkpointing) is an application-level checkpointing tool focused on the insertion of fault tolerance into long-running MPI applications. This paper presents an extension to CPPC to allow the checkpointing of OpenMP applications. The proposed solution maintains the main characteristics of CPPC: portability and reduced checkpoint file size. The performance of the proposal is evaluated using the OpenMP NAS Parallel Benchmarks showing that most of the applications present small checkpoint overheads.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0692

Authors: Rodrigo Andrade, Henrique Rebelo, Márcio Ribeiro, Paulo Borba

Abstract: In Software Product Lines (SPL), we can bind reusable features to compose a product at different times, which in general are static or dynamic. The former allows customizability without any overhead at runtime. On the other hand, the latter allows feature activation or deactivation while running the application with the cost of performance and memory consumption. To implement features, we might use aspect-oriented programming (AOP), in which aspects enable a clear separation between invariable code and variable code. In this context, recent work provides AspectJ-based idioms to implement flexible feature binding. However, we identified some design deficiencies. Thus, to solve the issues of these idioms, we incrementally create three AspectJ-based idioms. We apply these idioms to provide flexible binding for 16 features from five different product lines. Moreover, to evaluate our idioms, we quantitatively analyze them with respect to code cloning, scattering, tangling, and size by means of software metrics. Besides that, we qualitatively discuss our idioms in terms of code reusability, changeability, instrumentation overhead, behavior, and feature interaction. In conclusion, we show evidences that our idioms address the issues of those existing ones.

HTML

XML

PDF

DOI: 10.3217/jucs-020-04-0534

Authors: Patricia Matsumoto, Eduardo Guerra

Abstract: An Adaptive Object Model (AOM) is a common architectural style for systems in which classes, attributes, relationships and behaviors of applications are represented as metadata consumed at runtime. This allows them to be very flexible and changeable at runtime, enabling their modification by end users without source code modification. Nevertheless, this flexibility comes with a cost of a greater complexity when developing the system, and therefore one usually uses a bottom-up approach, adding flexibility only when it is needed. As a consequence, many AOM components are tied to the specific domain of a single application and this fact makes it difficult to develop and use generic and reusable AOM frameworks that properly handle specific requirements of the AOM architecture. This work presents an architectural model that aims to adapt domain-specific AOM core structures to a common core structure by identifying AOM roles played by each element through custom metadata configuration. By doing this, this model allows the integration of domain-specific AOM applications and AOM frameworks, making it feasible to develop reusable components for the AOM architecture. This model is evaluated by creating an AOM framework and a case study based on it, in which is performed a modularity and a performance analysis.

HTML

XML

PDF

DOI: 10.3217/jucs-019-05-0619

Authors: Dilek Karahoca

Abstract: This paper presents a Meta-Cognitive Tool (MCT) development for history teaching. It was developed to support teaching history of civilization courses at the engineering faculty. It covers hierarchically arranged concept maps which are presented dynamically by using Extensible Markup Language (XML) files. MCTs are integrated in e-learning portals to support self-learning. MCTs were investigated in terms of the Human Computer Interaction (HCI) discipline to evaluate their usability in online courses. For this purpose, relationships between learners' cognitive abilities, individual differences, and usability of e-learning portal were considered in order to create a model between individual differences and software usability. The usability of MCT was evaluated by 116 (70 male, 46 female) subjects who were registered for the HUM1005 History of Civilization I, a general elective course at the faculty of engineering. They completed four different surveys: an IQ survey, a personality survey, a motivation survey, and a software usability measurement inventory (SUMI). This research compares intelligence, personal factors, and motivation factors with the personal software usability results in order to determine the correlations and associations between the usability of the software and learners’ individual differences. In the study, results show that the usability of any education tool has effect on achievement of the learner. Noteworthy, a correlation was found between Grade Point Average (GPA) and usability scores.

HTML

XML

PDF

DOI: 10.3217/jucs-018-14-1987

Authors: Jörg Keller, Christoph Kessler, Rikard Hultén

Abstract: Limited bandwidth to off-chip main memory tends to be a performance bottleneck in chip multiprocessors, and this will become even more problematic with an increasing number of cores. Especially for streaming computations where the ratio between computational work and memory transfer is low, transforming the program into more memory-efficient code is an important program optimization. On-chip pipelining reorganizes the computation so that partial results of subtasks are forwarded immediately between the cores over the high-bandwidth internal network, in order to reduce the volume of main memory accesses, and thereby improves the throughput for memory-intensive computations. At the same time, throughput is also constrained by the limited amount of on-chip memory available for buffering forwarded data. By optimizing the mapping of tasks to cores, balancing a trade-off between load balancing, buffer memory consumption, and communication load on the on-chip network, a larger buffer size can be applied, resulting in less DMA communication and scheduling overhead. In this article, we consider parallel mergesort as a representative memory-intensive application in detail, and focus on the global merging phase, which is dominating the overall sorting time for larger data sets. We work out the technical issues of applying the on-chip pipelining technique, and present several algorithms for optimized mapping of merge trees to the multiprocessor cores. We also demonstrate how some of these algorithms can be used for mapping of other streaming task graphs. We describe an implementation of pipelined parallel mergesort for the Cell Broadband Engine, which serves as an exemplary target. We evaluate experimentally the influence of buffer sizes and mapping optimizations, and show that optimized on-chip pipelining indeed speeds up, for realistic problem sizes, merging times by up to 70% on QS20 and 143% on PS3 compared to the merge phase of CellSort, which was by now the fastest merge sort implementation on Cell.

HTML

XML

PDF

DOI: 10.3217/jucs-018-02-0143

Authors: David Lizcano, Fernando Alonso, Javier Soriano, Genoveva López

Abstract: End-user development (EUD) is much hyped, and its impact has outstripped even the most optimistic forecasts. Even so, the vision of end users programming their own solutions has not yet materialized. This will continue to be so unless we in both industry and the research community set ourselves the ambitious challenge of devising end to end an end-user application development model for developing a new age of EUD tools. We have embarked on this venture, and this paper presents the main insights and outcomes of our research and development efforts as part of a number of successful EU research projects. Our proposal not only aims to reshape software engineering to meet the needs of EUD but also to refashion its components as solution building blocks instead of programs and software developments. This way, end users will really be empowered to build solutions based on artefacts akin to their expertise and understanding of ideal solutions.

HTML

XML

PDF

DOI: 10.3217/jucs-017-11-1572

Authors: Leo Ordinez, David Donari, Rodrigo Santos, Javier Orozco

Abstract: In this paper, the Behavioral Importance Priority Server (BIPS) algorithm is proposed to schedule sets of hard/soft real-time tasks. The mechanism postpones or advances the execution of the next instance of a task according to the value obtained from a function properly associated to the behavior of the task; as a consequence, there is a flexible adaptation of the bandwidth required by each server. A synchronization method is introduced to prevent deadlocks and priority inversions in the case of sets of tasks sharing resources along with the necessary and sufficient conditions for the schedulability analysis. A software framework proposing an abstract architecture of a system based on BIPS is also presented. The BIPS software framework intends to bridge the gap between theoretical scheduling aspects and the actual implementation of them. Since BIPS is capable of managing very different sets of tasks, it covers a wide variety of applications found in the real world.

HTML

XML

PDF

DOI: 10.3217/jucs-017-04-0605

Authors: Peter Schultes, Franz Lehrer, Harald Kosch

Abstract: Interactive video is increasingly becoming a more and more dominant feature of our media platforms. Especially due to the popular YouTube annotations framework, integrating graphical annotations in a video has become very fashionable these days. However, the current options are limited to a few graphical shapes for which the user can define as good as no dynamic behaviour. Despite the enormous demand for easy-creatable, interactive video there are no such advanced tools available. In this article we describe an innovative approach, to realize dynamics and interactivity of video annotations. First we explain basic concepts of video-markup like the generic element model and visual descriptors. After that we introduce the event-tree model, which can be used to define event-handling in an interactive video formally as well as visually. By combining these basic concepts, we can give an effective tool to the video community for realizing interactive and dynamic video in a simple, intuitive and focused way.

HTML

XML

PDF

DOI: 10.3217/jucs-016-15-2081

Authors: Juan López, Montserrat Sendín

Abstract: The use of contextual information in mobile devices is receiving increasing attention in mobile and ubiquitous computing research. An important requirement for mobile development today is that devices should be able to interact with the context. In this paper we present a series of contributions regarding previous work on context-awareness. In the first place, we describe a client-server architecture that provides a mechanism for preparing target non context-aware applications in order to be delivered as context-aware applications in a semi-automatic way. Secondly, the framework used in the server to instantiate specific components for context-awareness, the Implicit Plasticity Framework, provides independence from the underlying mobile technology used in client device, as it is shown in the case studies presented. Finally, proposed infrastructure deals with the interaction among different context constraints provided by diverse sensors. All of these contributions are extensions to the infrastructure based on the Dichotomic View of plasticity, which now offers multi-purpose support.

HTML

XML

PDF

DOI: 10.3217/jucs-016-02-0296

Authors: Kurt Nørmark

Abstract: Lisp programmers constantly carry out experiments in a read-eval-print loop. The experimental activities convince the Lisp programmers that new or modified pieces of programs work as expected. But the experiments typically do not represent systematic and comprehensive unit testing efforts. Rather, the experiments are quick and dirty one shot validations which do not add lasting value to the software, which is being developed. In this paper we propose a tool that is able to collect, organize, and re-validate test cases, which are entered as expressions in a read-eval-print loop. The process of collecting the expressions and their results imposes only little extra work on the programmer. The use of the tool provides for creation of test repositories, and it is intended to catalyze a much more systematic approach to unit testing in a read-evalprint loop. In the paper we also discuss how to use a test repository for other purposes than testing. As a concrete contribution we show how to use test cases as examples in library interface documentation. It is hypothesized--but not yet validated--that the tool will motivate the Lisp programmer to take the transition from casual testing to systematic testing.

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-14-2894

Authors: Gabriel Rodríguez, María Martín, Patricia González, Juan Touriño

Abstract: Checkpointing tools may be typically implemented at two different abstraction levels: at the system level or at the application level. The latter has become a more popular alternative due to its flexibility and the possibility of operating in different environments. However, application-level checkpointing tools often require the user to manually insert checkpoints in order to ensure that certain requirements are met (e.g. forcing checkpoints to be taken at the user code and not inside kernel routines). The approach presented in this work is twofold. First, a spatial coordination protocol for checkpointing parallel SPMD applications is proposed, based on forcing checkpoints to be taken at the same places in the application code by all processes. Thus, global consistency is achieved without adding any new runtime communications or piggybacked data, and without the need to use specific fault-tolerant message-passing implementations. Second, the paper also introduces a compilation technique for the automatic insertion of checkpoints using the spatial coordination protocol, based on a static analysis of communications and a heuristic analysis of computational load. These analyses can also be used to achieve automatic checkpoint insertion in approaches based on classical protocols, such as uncoordinated checkpointing or distributed snapshots.

HTML

XML

PDF

DOI: 10.3217/jucs-015-11-2254

Authors: Camila Nunes, Uira Kulesza, Cláudio Anna, Ingrid Nunes, Alessandro Garcia, Carlos Lucena

Abstract: A multi-agent system product line (MAS-PL) defines an architecture, whose design and implementation is accomplished using software agents to address its common and variable features. MAS-PL promotes the large-scale reuse of common and variable agency features across multiple MAS applications. The development of MAS-PLs can be achieved through MAS-specific platforms and implementation techniques, such as conditional compilation and aspect-oriented programming (AOP). However, there is not much evidence on how these techniques provide better modularity, allowing the conception of stable MAS-PL designs. This paper presents a quantitative study on the design modularity and stability of an evolving MAS-PL. The MAS-PL was built following the reactive product line adoption approach. The product line was developed and evolved based on several versions of a conference management web-based system, named Expert Committee (EC). Our evaluation is made through a series of change scenarios related to new agency features, which are agent characteristics that enhance the system with autonomous behavior. The quantitative study consists of a systematic comparison between two different versions of the EC MAS-PL based on a MAS-specific platform, called JADE. One version was implemented with object-oriented and conditional compilation techniques. The other one relied on AOP. Our analysis was driven by well-known modularity and change impact metrics.

HTML

XML

PDF

DOI: 10.3217/jucs-015-09-1970

Authors: Po-Huan Chiu, Chi-Chun Lo, Kuo-Ming Chao

Abstract: Object-oriented programming (OOP) is a mainstream paradigm for engineering design software tool development. An emerging requirement is the introduction of semantics to achieve heterogeneous information sharing, but many challenges exist. Examples include using object methods to manipulate an RDF data, automatically converting data into RDF format, and supporting various programming languages. In addition, limitations to description capabilities for relationships among object-oriented classes exceed those of RDF, thus hindering direct mapping between object-oriented and Semantic Web classes. Our proposed semantic object framework (SOF) combines object-oriented design and Semantic Web features. SOF utilizes embedded comments in source code to describe semantic relationships between classes and attributes. We use a mobile phone design case study to illustrate how the proposed system operates.

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-015-01-0072

Authors: Lindsay Groves

Abstract: Verification of concurrent algorithms has been the focus of much research over a considerable period of time, and a variety of techniques have been developed that are suited to particular classes of algorithm, for example algorithms based on message passing or mutual exclusion. The development of nonblocking or lock-free algorithms, which rely only on hardware primitives such as Compare And Swap, present new challenges for verification, as they allow greater levels of currency and more complex interactions between processes. In this paper, we describe and compare two approaches to reasoning about nonblocking algorithms. We give a brief overview of the simulation approach we have used in previous work. We then give a more detailed description of an approach based on Lipton's reduction method, and illustrate it by verifying two versions of a shared counter and two versions of a shared stack. Both approaches work by transforming a concurrent execution into an equivalent sequentia-execution, but they differ in the way that executions are transformed and the way that transformations are justified.

HTML

XML

PDF

DOI: 10.3217/jucs-015-01-0003

Authors: Egon Börger, Ove Sörensen, Bernhard Thalheim

Abstract: The recent literature on business process modeling notations contains numerous contributions to the so-called OR-join (or inclusive merge gateway) problem. We analyze the problem and present an approach to solve it without compromising any of the two major concerns that are involved: a) a clear semantical definition (design), which also clarifies what has to be implemented to achieve the intended generality of the construct, and b) a comprehensive set of static and dynamic analysis methods (verification of properties of business process models using the construct). We provide a conceptually simple scheme for dynamic OR-join synchronization policies, which can be implemented with low run-time overhead and allows the practitioner to effectively link the design of business process models with OR-joins to an analysis of the intended model properties. The definitions have been experimentally validated by a graph-based simulator.

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-3517

Authors: Rodolfo Toledo, Éric Tanter

Abstract: Extending AspectJ to experiment with new language features can be cumbersome, even with an extensible implementation. Often, a language designer only needs a rapid prototyping environment, but has to deal with a full compiler infrastructure, and must address low-level implementation issues. This work completes a lightweight extensible implementation of AspectJ with a declarative assimilation layer based on Stratego. This layer brings together an extensible syntax definition of AspectJ and the core semantics provided by the Reflex AOP kernel. Using this implementation, language extensions are defined using declarative high-level constructs, significantly reducing the cost of the extension process.

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-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-21-3414

Authors: Martijn Schrage, S. Swierstra

Abstract: Proxima is a generic structure editor suitable for a wide range of structured document types. It allows edit operations on the document structure as well as on its screen representation (i.e. free-text editing), without the need to switch between the two modes. The system maintains a bidirectional mapping between the document structure and its presentation. Besides obvious applications, such as word-processor and spread-sheet editors, Proxima is especially well-suited for defining source editors for programming languages. Presentation-oriented edit operations require that an edited presentation can be parsed to yield an updated document structure. However, conventional parsing techniques cannot readily be applied, since presentations in Proxima are not restricted to text but may also contain graphical elements. For example, an exponential may be presented as 32. Although this graphical presentation may not be directly edited at the presentation level, its components may. Hence, instead of simply parsing the changed representation, we have to take into account the existing structure. This paper explains the scanning and parsing process for presentations that are a possibly nested combination of text and graphical elements. For textual parts of the presentation a Haskell combinator parser needs to be provided. The parser for graphical parts, on the other hand, is constructed by Proxima, based on information in the presentation. White space in the presentation can be handled automatically, if desired.

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-18-3031

Authors: Giorgia Mattos, Andrei Formiga, Rafael Lins, Francisco Heron de Carvalho Júnior, Fernando Mário Junqueira Martins

Abstract: BigBatch is an image processing environment designed to process batches of thousands of monochromatic documents. One of the flexibilities and pioneer aspects of BigBatch is offering the possibility of working in distributed environments such as clusters and grids. This paper presents an overview of BigBatch image processing features and analyzes the results of a number of experiments devised to compare its cluster and grid configurations. Although preliminary results were published earlier on, the new data shown here that sheds new lights onto this aspect. The results obtained exhibit almost no difference in total execution times for some grid and cluster configurations, but significant differences for others, indicating that the choice between such configurations must take into account a number of details in order to reach peak performance. Besides those, there are other qualitative aspects that may impact this choice. This paper analyzes these aspects and provides a general picture of how to successfully use BigBatch to process document images employing computers in parallel for this task.

HTML

XML

PDF

DOI: 10.3217/jucs-014-14-2343

Authors: Botond Virginas, Marian Ursu, Edward Tsang, Gilbert Owusu, Chris Voudouris

Abstract: This paper considers the problem of resource allocation in the service industries approached from an agent-based perspective. Agent technologies seem to be well suited to this domain by providing a distributed environment, are network centric, semi-autonomous and collaborative and can communicate with each other to achieve better optimisation with little human intervention. The paper describes the context of this solution, a general power model and several pathways with corresponding example implementations with results and discussion The novelty of the solution resides in the fact that it is a natural and versatile formulation that combines an agent-based model with various artificial intelligence and operations research techniques such as rule-based expressions of allocation strategies and multi-criteria optimisation expressions of allocation objectives.

HTML

XML

PDF

DOI: 10.3217/jucs-014-13-2158

Authors: Enrico Oliva, Antonio Natali, Alessandro Ricci, Mirko Viroli

Abstract: This paper describes a Java-based framework for developing componentbased software systems supporting adaptation with logic laws and considering component interactions as a first-class aspect. On the one side, the framework makes it possible to specify the logic of interaction at the component-level, in terms of input and output interfaces, the events generated and observed by a component, and related information about the management of the control flow. On the other side, it is possible to specify the logic of interaction at the inter-component level, providing a modelling and linguistic support for designing and (dynamically) programming the glue among the components, enabling general forms of adaptation, observation and construction of the interaction space. As a result, the framework supports the adaptation of components at different levels: from interoperability among heterogeneous and unknown components, to the support for dynamic introduction, removal and update of components, to general coordination patterns, such as workflow. The framework uses first-order logic as the reference computational model for describing and defining the logic of interaction: the modalities adopted by components to interact, the adaptation laws gluing the components and the interaction events occurring in the system are expressed as facts and rules. They compose the (evolving) logic theories describing and defining the interaction at the system level, and can be observed and controlled at runtime to allow dynamic re-configurability.

HTML

XML

PDF

DOI: 10.3217/jucs-014-11-1838

Authors: Paula Montoto, Alberto Pan, Juan Raposo, Jose Losada, Fernando Bellas, Víctor Carneiro

Abstract: Most today’s web sources do not provide suitable interfaces for software programs to interact with them. Many researchers have proposed highly effective techniques to address this problem. Nevertheless, ad-hoc solutions are still frequent in real-world web automation applications. Arguably, one of the reasons for this situation is that most proposals have focused on query wrappers, which transform a web source into a special kind of database in which some queries can be executed using a query form and return resultsets that are composed of structured data records. Although the query wrapper model is often useful, it is not appropriate for applications that make decisions according to the data retrieved or processes that use forms that can be modelled as insert/update/delete operations. This article proposes a new language for defining web automation processes that is based on a wide range of real-world web automation tasks that are being used by corporations from different business areas.

HTML

XML

PDF

DOI: 10.3217/jucs-013-13-2002

Authors: Lorenzo Capra, Walter Cazzola

Abstract: Nowadays, software evolution is a very hot topic. It is particularly complex when it regards critical and nonstopping systems. Usually, these situations are tackled by hard-coding all the foreseeable evolutions in the application design and code. Neglecting the obvious difficulties in pursuing this approach, we also get the application code and design polluted with details that do not regard the current system functionality, and that hamper design analysis, code reuse and application maintenance in general. Petri Nets (PN), as a formalism for modeling and designing distributed/concurrent software systems, are not exempt from this issue. The goal of this work is to propose a PN based reflective framework that lets everyone model a system able to evolve, keeping separated functional aspects from evolutionary ones and applying evolution to the model only if necessary. Such an approach tries to keep system's model as simple as possible, preserving (and exploiting) ability of formally verifying system properties typical of PN, granting at the same time adaptability.

HTML

XML

PDF

DOI: 10.3217/jucs-013-11-1722

Authors: Alexandru Popa, Alexandru Sofronia, Gheorghe Stefanescu

Abstract: A model (consisting of rv-systems), a core programming language (for developing rv-programs), several specification and analysis techniques appropriate for modeling, programming and reasoning about interactive computing systems have been introduced by Stefanescu in 2004 using register machines and space-time duality, see [Stefanescu 2006, Stefanescu 2006b]. Later on, Dragoi and Stefanescu have introduced structured programming techniques for programming rv-systems and have presented a kernel programming language AGAPIA v0.1 for interactive computing systems, see [Dragoi and Stefanescu 2006a, Dragoi and Stefanescu 2006b]. AGAPIA v0.1 has a restricted format for program construction, using a "3-level" grammar for their definition: the procedure starts with simple while programs, then modules are defined, and finally AGAPIA v0.1 programs are obtained applying structured rvprogramming statements on top of modules. In the current paper the above restriction is completely removed. By an appropriate reshaping interface technique, general programs may be encapsulated into modules, allowing to reiterate the above "3-level" construction of programs, now starting with arbitrary AGAPIA programs, not with simple while programs. This way, high-level interactive programs are obtained. The extended version is called AGAPIA v0.2. As a case study we consider a cluster of computers, each having a dynamic set of running processes. We present a protocol for the communication and termination detection in this system and implement the protocol in our AGAPIA v0.2 language. We also describe the operational semantics of the program using high-level scenarios, i.e., scenarios where, recursively, the cells may themselves contain scenarios, at a lower, refined level.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0891

Authors: André Maidl, Claudio Carvilhe, Martin Musicante

Abstract: Object-Oriented Action Semantics is a semantic framework for the definition of programming languages. The framework incorporates some object-oriented concepts to the Action Semantics formalism. Its main goal is to obtain more readable and reusable semantic specifications. ObjectOriented Action Semantics provides support for the definition of syntax-independent specifications, due to the way its classes are written. In a previous work, a library of classes (called LFL) was developed to improve specification reuse and to provide a way to describe semantic concepts, independent from the syntax of the programming language. This paper aims to address some problematic aspects of LFL, and presents a case study, where a specification is built by using the Visitor Pattern technique. The use of this pattern allows a clear separation between the syntax of a programming language and its different semantic aspects.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0854

Authors: Nuno Rodrigues, Luís Barbosa

Abstract: Program slicing is a well known family of techniques intended to identify and isolate code fragments which depend on, or are depended upon, specific program entities. This is particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, and corresponding tools, target either the imperative or the object oriented paradigms, where program slices are computed with respect to a variable or a program statement.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0817

Authors: Andrei Formiga, Rafael Lins

Abstract: Multi-processor systems have become the standard in current computer architectures. Software developers have the possibility to take advantage of the additional computing power available to concurrent programs. This paper presents a way to automatically use additional processors, by performing memory management concurrently. A new architecture with little explicit synchronization for concurrent lazy cyclic reference counting is described. This architecture was implemented and preliminary performance tests point at significant efficiency improvements over the sequential counterpart.

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-0767

Authors: Vladimir O. Di Iorio, Débora Coura, Leonardo Reis, Marcelo Oikawa, Carlos Junior

Abstract: This paper presents a visual language for producing animated simulations. The language is implemented on a tool called Tabajara Animator, using principles of Programming By Demonstration (PBD), which is a technique for teaching the computer new behaviour by demonstrating actions on concrete examples. The language is based on a formal model for concurrent update of agents, which represent the animated characters. The visual rules follow the "before-after" style, adopted by the most important similar tools. New features discussed by this work may produce a significant reduction on the number of required rules for producing animated simulations. This paper shows how these new features are implemented on a visual user-friendly interface, and how they are translated into structures of the formal model adopted.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0721

Authors: Leandro De Freitas, Marcel Caraciolo, Márcio Cornélio

Abstract: Programming laws are a means of stating properties of programming con-structs and resoning about programs. Also, they can be viewed as a program transformation tool, being useful to restructure object-oriented programs. Usually the appli-cation of a programming law is only allowed under the satisfaction of side-conditions. In this work, we present how the conditions associated to object-oriented program-ming laws are checked by using Prolog. This is a step towards a tool that allows user definable refactorings based on the application of programming laws.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0701

Authors: Jacques Robin, Jairson Vitorino, Armin Wolf

Abstract: Most automated reasoning tasks with prac tical applications can be automatically reformulated into a constraint solving task. A constraint programming platform can thus act as a unique, underlying engine to be reused for mu ltiple automated reasoning tasks in intelligent agents and systems. We identify six key requirements for such platform: expressive task modeling language, rapid solving method custom ization and combination, adaptive solving method, user-friendly solution explanation, efficient execution, and seamless integration within larger systems and practical applications. We then propose a novel, model-driven, component and rule-based architecture for such a platform that better satisfies as a whole this set of requirements than those of currently available platforms.

HTML

XML

PDF

DOI: 10.3217/jucs-013-02-0149

Authors: Rai Chan, Junichi Hoshino

Abstract: Generating composite human motion such as locomotion and gestures is important for interactive applications, such as interactive storytelling and computer games. In interactive story environments, CG characters do not merely stand in one position. Rather, they should be able to compose gestures and locomotion based on the discourse of the story and the locations of objects in the scene. Thus, in the present paper, we propose a conversational locomotion model for CG character. We constructed a conversational locomotion network for a virtual environment. A multi-path searching algorithm calculates the optimal walking path, which uses node activation from the story locations and conversation units. The CG character also locally adjusts its position so that it does not block the referenced object from the user’s sight. We have applied the proposed technique to an interactive 3D movie system and have demonstrated composite motion of the locomotion and conversation of a CG character, which improves the immersion of the viewer in the story environment.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1679

Authors: Pascual Julián, Ginés Moreno, Jaime Penabad

Abstract: Multi-adjoint logic programming represents a very recent, extremely flexible attempt for introducing fuzzy logic into logic programming. In this setting, the execution of a goal w.r.t. a given program is done in two separate phases. During the operational one, admissible steps are systematically applied in a similar way to classical resolution steps in pure logic programming, thus returning a computed substitution together with an expression where all atoms have been exploited. This last expression is then interpreted under a given lattice during the so called interpretive phase, hence returning a value which represents the fuzzy component (truth degree) of the computed answer. On the other hand, unfolding is a well known transformation rule widely used in declarative programming for optimizing and specializing programs, among other applications. In essence, it is usually based on the application of operational steps on the body of program rules. The novelty of this paper consists in showing that this process can also be made in terms of interpretive steps. We present two strongly related kinds of unfolding (operational and interpretive), which, apart from exhibiting strong correctness properties (i.e. they preserve the semantics of computed substitutions and truth degrees) they are able to significantly simplify the two execution phases when solving goals.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1651

Authors: Jesús Almendros-Jiménez, Antonio Becerra-Terón, Francisco Enciso-Baños

Abstract: The eXtensible Markup Language (XML) is considered as the format of choice for the exchange of information among various applications on the Internet. Since XML is emerging as a standard for data exchange, it is natural that queries among applications should be expressed as queries against data in XML format. This use gives rise to a requirement for a query language expressly designed for XML resources. World Wide Web Consortium (W3C) convened to create the XQuery language, concretely, a typed functional language for querying XML documents. One key aspect of the XQuery language is the use of the XPath language as basis for handling the structure of an XML document. In this paper, we present a proposal for the representation of XML documents by means of a logic program. Rules and facts can be used for representing the document schema and the XML document itself. In addition, we study how to query by means of the XPath language against a logic program representing an XML document. It evolves the specialization of the logic program with regard to the XPath expression. This specialization technique is based on the well-known transformation technique called Magic Sets and studied for deductive databases. The bottom-up evaluation of the speciali

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1594

Authors: José Cleva, Isabel Pita

Abstract: We present a novel approach to the verification of functional-logic programs. For our verification purposes, equational reasoning is not valid due to the presence of non-deterministic and partial functions. Our approach transforms functionallogic programs into Maude theories and then uses the Rewriting Logic logical framework to verify properties of the transformed programs. We propose an inductive proving method based on the length of the computation on the Rewriting Logic framework to cope with the non-deterministic and non-terminating aspects of the programs. We illustrate the application of the method on various examples, where we analyze the sequence of steps to be performed by the proof in order to get expertise for the automatization of the process. Then, since the proposed transformation process is also amenable of automatization, we will obtain a tool for proving properties of CRWL programs. Another advantage of our methodology, that distinguish it from other approaches, is that it does not confuse the original functional-logic program with the subjects we want to talk about in the properties, but it allows the equational definition of observations on top of the transformed programs which simplifies the obtained proofs.

HTML

XML

PDF

DOI: 10.3217/jucs-012-11-1574

Authors: Jaime Sánchez-Hernández

Abstract: Functional-logic programming amalgamates some of the main features of both functional and logic styles into a single paradigm. Nevertheless, negation is a widely investigated feature in logic programming that has not received much attention in such programming style. It is not difficult to incorporate some kind of negation as finite failure for ground goals, but we are interested in a constructive version able to deal with non-ground goals. With this aim, in previous works we have built a formal framework for checking (finite) failure of reduction. In this paper we adapt it for implementing a prototype for a functional-logic language with constructive failure as the natural counterpart to negation in logic programming.

HTML

XML

PDF

DOI: 10.3217/jucs-012-09-1229

Authors: András Hajdu, János Kormos, Zsolt Lencse, Lajos Trón, Miklós Emri

Abstract: In this paper we present the structure and the achieved results of the R&D project IKTA-4, 6/2001 MEDIP - Platform independent software system for medical image processing supported by the Hungarian Ministry of Education. The aim of the project was to develop a software background for our basic and applied research in the field of medical imaging that can be used in clinical routine, as well. Realization was based on the experience of information technology and medical imaging research university teams and a company specialized on software and hardware developing for nuclear medicine. The aims also reflect some former research and development activities of the participants. Thus some of them are well experienced in registration, segmentation and image fusion techniques. These experiences were also considered in the determination of the main purposes. The capabilities of the provided software library were demonstrated through test applications from the fields of orthopedics, oncology and nuclear medicine.

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-08-1007

Authors: Angela French, Jose Amaral

Abstract: The seminal algorithm developed by Ron Cytron, Jeanne Ferrante and colleagues in 1989 for the placement of φ-nodes in a control flow graph is still widely used in commercial compilers. Placing φ-nodes is necessary when converting a program representation to Static Single Assignment (SSA) form. This paper shows that if a variable x is defined in a set of basic blocks A(x), then the iterated join set of A(x) can be decomposed into the computation of the iterated join set of a disjoint collection of subsets of A(x). We use this result to show that some join set computations are redundant. We measured the number of redundant computations in the Open Research Compiler (ORC) in a selection of SPEC 2000 benchmarks.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0958

Authors: Júlio Machado, Paulo Menezes

Abstract: UML may be used to describe both the structure and behavior of objectoriented systems using a combination of notations. For the modeling of the dynamic behavior, a number of different models are offered such as interaction, state and activity diagrams. Although compositional techniques for modeling computational processes demand means of composing elements both in non-atomic or atomic ways, UML seems to lack compositional constructs for defining atomic composites. We discuss proper extensions for diagrams that are able to cope with the concept of atomic composition as the basic element for describing transactions (in our settings the term "transaction" denotes a certain operation of a system that might be atomically composed by many, possibly concurrent, operations). Atomic compositions are then formally defined through a special morphism between automata in a domain called Nonsequential Automata.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0885

Authors: Alcides Calsavara, Aron Borges, Leonardo Nunes, Diogo Variani, Carlos Kolb

Abstract: Most modern computer applications should run on heterogeneous platforms and, moreover, objects and respective code should be easily interchangeable between distinct platforms at runtime. This paper describes a runtime platform based on distributed and cooperating virtual machines named Virtuosi. A unified object model permits easy inter-operation between applications written on different languages. All applications must be compiled to a standard runtime code format so they all can run on any platform where an implementation of the virtual machine exists. A novel code format which is entirely based on instances of the classes that define the object model itself is employed. A proper programming language has been defined, a corresponding compiler implemented, a virtual machine that includes a class loader, a code interpreter, a single-threaded execution control and a distributed object store implemented and tested through example applications.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0849

Authors: Markus Schordan

Abstract: Design patterns have been developed to cope with the vast space of possible different designs within object-oriented systems. One of those classic patterns is the Visitor Pattern, used for representing an operation to be performed on the elements of an object structure. In general, the order in which the objects are visited is crucial. We present a mapping from the Visitor Pattern to a context free grammar that defines the set of all such visit sequences, a given Visitor can perform. The language defined by this grammar is the language of the Visitor Design Pattern and the mapping encodes knowledge about the class hierarchy and the implementation of the accept methods of a Visitor Design Pattern. It is general enough to model complications that occur when traversing arbitrary object structures, and also properly represents cases such as lack of a common base class, multiple inheritance, and inheritance from concrete classes. Due to its particular design, the grammar can also be used as precise documentation for a Visitor Design Pattern.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0828

Authors: Nuno Rodrigues, Luís Barbosa

Abstract: Program slicing is a well known family of techniques used to identify code fragments which depend on or are depended upon specific program entities. They are particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, usually oriented towards the imperative or object paradigms, are based on some sort of graph structure representing program dependencies. Slicing techniques amount, therefore, to (sophisticated) graph transversal algorithms. This paper proposes a completely different approach to the slicing problem for functional programs. Instead of extracting program information to build an underlying dependencies' structure, we resort to standard program calculation strategies, based on the so-called Bird-Meertens formalism. The slicing criterion is specified either as a projection or a hiding function which, once composed with the original program, leads to the identification of the intended slice. Going through a number of examples, the paper suggests this approach may be an interesting, even if not completely general, alternative to slicing functional programs.

HTML

XML

PDF

DOI: 10.3217/jucs-012-07-0811

Authors: Eduardo Piveta, Marcelo Hecht, Marcelo Pimenta, Roberto Price

Abstract: This paper defines algorithms to automatically detect five types of bad smells that occur in aspect-oriented systems, more specifically those written using the AspectJ language. We provide a prototype implementation to evaluate the detection algorithms in a case study, where bad smells are detected in three well-known AspectJ systems.

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-10-1580

Authors: A. Cruz, Luís Barbosa, José Oliveira

Abstract: This paper addresses objectification, a formal specification technique which inspects the potential for object-orientation of a declarative model and brings the 'implicit objects' explicit. Criteria for such objectification are formalized and implemented in a runnable prototype tool which embeds Vdm-sl into Vdm++. The paper also includes a quick presentation of a (coinductive) calculus of such generated objects, framed as generalised Moore machines.

HTML

XML

PDF

DOI: 10.3217/jucs-011-05-0744

Authors: Jean-Raymond Abrial, Dominique Cansell

Abstract: This paper contains a completely formal (and mechanically proved) development of some algorithms dealing with a linked list supposed to be shared by various processes. These algorithms are executed in a highly concurrent fashion by an unknown number of such independent processes. These algorithms have been first presented in [MS96] by M.M. Michael and M.L. Scott. Two other developments of the same algorithms have been proposed recently in [YS03] (using the 3VMC Model Checker developed by E. Yahav) and in [DGLM04] (using I/O Automata and PVS).

HTML

XML

PDF

DOI: 10.3217/jucs-011-05-0687

Authors: Jörg Kienzle

Abstract: This paper shows how the concept of atomicity can ease the development of concurrent software. It illustrates by means of a case study how atomicity is used to reduce the complexity of concurrency by presenting simplified models or views of the system at certain stages of the development cycle. As the development process goes on, the atomic views from the early stages are refined - broken up into smaller pieces - to slowly introduce concurrency back into the system. Finally, at the design stage, low-level concepts that provide atomicity, such as transaction or monitors, are used to ensure consistent concurrent updating of the application state.

HTML

XML

PDF

DOI: 10.3217/jucs-010-10-1429

Authors: Cristina Seceleanu, Tiberiu Seceleanu

Abstract: We concentrate on two major aspects of reactive system design: behavior control and modularity. These are studied from a formal point of view, within the framework of action systems. The traditional interleaving paradigm is completed with a barrier synchronization mechanism. This is achieved by introducing a new parallel composition operator, applicable to bot h discrete and hybrid models. While offering improvements with respect to control and modularity, the approach uses the correctness preserving mechanisms provided by the underlying reasoning environment 1. 1) A shorter version of this study appeared as "Modular Design of Reactive Systems", in Proceedings of the 28th Annual International Computer Software and Applications Conference (COMPSAC 2004), IEEE Computer Society Press, September 2004, Hong Kong. Pages 265-271.

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-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-0859

Authors: Brian Westphal, Frederick C. Harris Jr., Sergiu Dascalu

Abstract: This paper presents an overview of the Redwood programming environment and details one of its key features, snippets. Through snippets, developers can both make use of a variety of predefined programming constructs and build their own reusable program components. Language-independent, snippets are descriptions of program parts that can be as simple as an assignment statement or as complex as a sophisticated optimization algorithm. In Redwood, snippets also provide support for a distinguishing facility of visual environments: direct manipulation via drag-and-drop. An example of working with snippets, including snippet definition, visualization, customization, and mapping to code is also presented in the paper.

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-010-07-0751

Authors: D. Turner

Abstract: The driving idea of functional programming is to make programming more closely related to mathematics. A program in a functional language such as Haskell or Miranda consists of equations which are both computation rules and a basis for simple algebraic reasoning about the functions and data structures they define. The existing model of functional programming, although elegant and powerful, is compromised to a greater extent than is commonly recognised by the presence of partial functions. We consider a simple discipline of total functional programming designed to exclude the possibility of non-termination. Among other things this requires a type distinction between data, which is finite, and codata, which is potentially infinite.

HTML

XML

PDF

DOI: 10.3217/jucs-010-04-0473

Authors: Mercedes Amor, Lidia Fuentes, Mónica Pinto

Abstract: Developing multimedia applications entails understanding a variety of advanced technologies, in addition, multimedia programming poses a significant challenge in terms of handling a variety of hardware devices, multimedia formats or communication protocols. Therefore, break-through software engineering technologies should be applied to produce reference architectures able to support ever-changing requirements. In this paper, we first present the challenges that designers must face in multimedia programming, and how current frameworks address them, specially regarding the management of architectural evolution. We then show what breakthrough approaches or technologies can be used to produce more reusable, extensible and open multi-media systems. We focus on presenting the benefits of applying component-based software development and application framework technologies. We also illustrate how to componentize all multimedia functionalities and (re)use the resulting components as COTS in application frame-works. This approach helps to add multimedia capabilities to an application without requiring specific knowledge on multimedia.

HTML

XML

PDF

DOI: 10.3217/jucs-010-04-0359

Authors: Jorge Gómez-Sanz, Juan Pavón

Abstract: As agent technology has matured with the deployment of a variety of applications, particularly in open and dynamic environments such as the web, several methodologies and tools have been proposed to support software engineers during the development process of such systems. This article takes an overall look at representative agent-oriented methodologies by considering how they support specific agent-related concepts. This serves to identify areas in which this technology has shown its potential to solve new problems, e.g., the ability to manage complexity with an organizational perspective, goal-driven modelling as a way to build robust behaviors for adaptive systems, or the definition of notation and mechanisms to implement high-level interactions and protocols between agents. In order to be fully applicable, the challenge today is the maturity of supporting tools, and new methods for validation and verification of multi-agent systems.

HTML

XML

PDF

DOI: 10.3217/jucs-009-09-1096

Authors: Lledó Museros, M. Escrig

Abstract: A qualitative representational model and the corresponding reasoning process for integrating time and topological information is developed in this paper. In the calculus presented, topological information in function of the point of the time in which it is true is represented as an instance of the Constraint Satisfaction Problem. The resulting method can be applied to qualitative navigation of autonomous agents. The model presented in this paper will help us during the path planning task by describing the sequence of topological situations that the agent should find during its way to the target objective. A preliminary result of that application has been obtained by using qualitative representation of such spatial aspects for the autonomous simulated navigation of a Nomad-200 robot, on a structured environment of an easy corridor in a building.

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-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-08-0745

Authors: Alvaro Figueira, Hervé Paulino, Luis Lopes, Fernando Silva

Abstract: We describe a programming language for distributed computations that supports mobile resources and is based on a process calculus. The syntax, semantics and implementation of the language are presented with a focus on the novel model of computation.

HTML

XML

PDF

DOI: 10.3217/jucs-009-08-0730

Authors: Marcus Leal, Noemi Rodriguez, Roberto Ierusalimschy

Abstract: With the goal of assessing the use of the tuple space model in the context of event-driven applications, we developed a reactive tuple space in the Lua programming language. This system, which we called LuaTS, extends the original Linda model with a more powerful associative mechanism for retrieving tuples, supports code mobility and includes a reactive layer through which the programmer can modify the behavior of the basic system calls. In this paper we describe the implementation of LuaTS and illustrate its main features with a few examples.

HTML

XML

PDF

DOI: 10.3217/jucs-009-02-0173

Authors: Walter Guttmann, Helmuth Partsch, Wolfram Schulte, Ton Vullinghs

Abstract: This paper describes the program transformation system Ultra. The intended use of Ultra is to assist programmers in the formal derivation of correct and efficient programs from high-level descriptive or operational specifications. We illustrate its utility by deriving a version of the Heapsort algorithm from a non-deterministic specification. Ultra supports equational reasoning about functional programs using defining equations, algebraic laws of underlying data structures, and transformation rules. The system does not only support modifying terms, but is also useful for bookkeeping and development navigating tasks. The most salient features of Ultra are its sound theoretical foundation, its extendability, its flexible and convenient way to express transformation tasks, its comfortable user interface, and its lean and portable implementation. Ultra itself is written in the functional language Gofer.

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-008-10-0881

Authors: Volker Mattick

Abstract: Design for All is an important challenge for hypermedia engineering. We analyze this challenge and show that it is necessary to find a way of describing partially designed hypermedia documents that can then be transformed into different hypermedia applications according to user needs and call this concept "semi-documents". We sketch similarities and differences to existing formalisms and conclude that there are three areas in which functional languages can make a contribution: the development of an embedded special-purpose language for describing semi-documents, the building of generators which produce hypermedia applications from semi-document, and the realization of support tools for the development of semi-documents.

HTML

XML

PDF

DOI: 10.3217/jucs-008-07-0674

Authors: Demissie Aredo

Abstract: This paper presents a framework for representing formal semantics of a subset of the Unified Modeling Language (UML) notation in a higher-order logic, more specifically semantics of UML sequence diagrams is encoded into the Prototype Verification System (PVS). The primary objective of our work is to make UML models amenable to rigorous analysis by providing their precise semantics. This approach paves a way for formal development of systems through a systematic transformation of UML models. This work is a part of a long-term vision to explore how the PVS tool set can be used to underpin practical tools for analyzing UML models. It contributes to the ongoing effort to provide mathematical foundation to UML notations, with the aim of clarifying the semantics of the language as well as supporting the development of semantically-based tools.

HTML

XML

PDF

DOI: 10.3217/jucs-008-01-0097

Authors: Klaus Schmaranz

Abstract: Two of today's most used buzz-words in the context of software development are the terms Componentware and Distributed Object-System. The combination of both ideas is then called a Distributed Component-System, meaning a componentware approach where the components are distributed across the network. Today's approaches fulfill the application developers' needs only partly. Also, most are more or less cumbersome to use. I want to call such part-solutions like e.g. Corba, Enterprise Java­Beans and others first generation distributed component systems. In fact, Corba has a different origin, but for the moment let me consider it to be a first generation componentware system, too. In this paper I want to identify the requirements that have to be fulfilled to design and implement a second generation distributed component system. One main aspect is behind all of the ideas of second generation systems: a good distributed component system is one that the application programmers don't notice. The open-source project Dinopolis is currently in its early implementation phase and can be considered the first second-generation distributed component system according to the requirements that are identified in the following. Therefore the very basic cornerstones of Dinopolis are discussed at the end of this paper.

HTML

XML

PDF

DOI: 10.3217/jucs-008-01-0002

Authors: Egon Börger

Abstract: The research belonging to the Abstract State Machines approach to system design and analysis is surveyed and documented in an annotated ASM bibliography. The survey covers the period from 1984, when the idea for the concept of ASMs (under the name dynamic or evolving algebras or structures) appears for the first time in a foundational context, to the year 2001 where a mathematically well-founded, practical system development method based upon the notion of ASMs is in place and ready to be industrially deployed. Some lessons for the future of ASMs are drawn.

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-02-0107

Authors: Rudolf Berghammer, Thorsten Hoffmann

Abstract: We use a relational characterization of binary direct sums to model sequences within the relation-algebraic manipulation and prototyping system RelView in a simple way. As an application we formally derive a RelView program for computing equivalence classes of an equivalence relation, where we combine relation-algebraic calculations with the so-called Dijkstra-Gries program development method. Also a refinement of the simple modeling is presented, which leads to the classical datatype of stacks, and a further application is sketched.

HTML

XML

PDF

DOI: 10.3217/jucs-007-01-0054

Authors: Wolfram Kahl, Frank Derichsweiler

Abstract: We show how the declarative spirit of attribute grammars can be employed to define an attribution mechanism for term graphs, where the non-uniqueness of inherited attributes demands an appropriately generalised treatment. Since term graphs are a useful data structure for symbolic computation systems such as theorem provers or program transformation systems, this mechanism provides a powerful means to generate concrete programs (and other relevant text or data structures) from their abstract term graph representations. We have implemented this declarative term graph attribution mechanism in the interactive term graph program transformation system HOPS and show a few simple examples of its use.

HTML

XML

PDF