Coordinating Java agents over the WWW

We introduce Jada, a programming toolkit for coordinating agents written in Java. Coordination among either concurrent threads or distributed Java objects is achieved via shared object spaces. By exchanging objects through object spaces, Java agents or applets can exchange data or synchronize their actions over the Internet, a LAN, a single host, or even inside a Javaenabled browser. The access to an object space is performed using a set of methods of an ObjectSpace object. Such operations inspired by the Linda language are powerful enough to solve several coordination problems. Moreover, we show how Jada can be used as a coordination kernel for more complex coordination architectures.     

High‐quality pagination for publishing

The problem of line breaking consists of finding the best way to split paragraphs into lines. It has been cleverly addressed by the total‐fit algorithm exposed by Knuth and Plass in a well‐known paper. Similarly, page‐breaking algorithms break the content flow of a document into page units. Formatting languages—such as the World Wide Web Consortium standard Extensible Stylesheet Language Formatting Objects (XSL‐FO)—allow users to set which content should be kept in the same page and how many isolated lines are acceptable at the beginning/end of each page. The strategies most formatters adopt to meet these requirements, however, are not satisfactory for many publishing contexts as they very often generate unpleasant empty areas. In that case, typographers are required to manually craft the results in order to completely fill pages. This paper presents a page‐breaking algorithm that extends the original Knuth and Plass line‐breaking approach and produces high‐quality documents without unwanted empty areas. The basic idea consists of delaying the definitive choice of breaks in the line‐breaking process in order to provide a larger set of alternatives to the actual pagination step. The algorithm also allows users to decide the set of properties to be adjusted for pagination and their variation ranges. An application of the algorithm to XSL‐FO is also presented, with an extension of the language that allows users to drive the pagination process. The tool, named FOP+, is a customized version of the open‐source Apache Formatting Objects Processor formatter. Copyright © 2011 John Wiley & Sons, Ltd.     

XML-Based Hypertext Functionalities for Software Engineering

Hypertext functionalities represent a form of the distilled wisdom of the hypermedia community. Even if they were introduced and advocated already in the pre-Web era, most of these functionalities are absent in current Web browsers. However, such functionalities can be very useful in some specific applicative fields, like for instance browsing complex software engineering documents, using standard WWW components. We propose to exploit the advent of XML as a basic infrastructure for describing software engineering hypertexts. In fact, we describe XMLC, a prototype of an XML browser that, given its modular architecture and general scope, can be seen as the basis for implementing sophisticated hypertext functionalities for software engineering documentation to be maintained and browsed on the Web.     

Declarative specification of the architecture of a software development environment

There is an increasing interest in the study of software architectures; however, it still unclear which kind of formalisms and techniques should be used in their design. We study the suitability of a rule-based, parallel logic language in the specification of the architecture of a complex software system, i.e. a software development environment. We have used as a case study SMILE, an environment for programming-in-the-large. Because of the declarative, concurrent and object-oriented features of parallel logic programming, we have been able to design a software architecture that emphasizes the dynamics of co-ordination inside the software development environment. The result of this experience shows the usefulness and some weaknesses of logic languages for specifying and prototyping the software architecture of a distributed interactive system.     

Parallel programming with logic languages: A survey

Formal properties of logic languages are largely studied; however, their impact on the practice of software design and programming is currently minimal. In this paper we survey some interesting representatives of the family of logic languages aiming at comparing the different capabilities they offer for designing and programming parallel systems. The logic languages Prolog, Aurora, Flat Concurrent Prolog, Parlog, GHC, and DeltaProlog were chosen, because a suitable set of relevant examples has been published, mostly by the language designers themselves. A number of sample programs is used to expose and compare the languages with respect to their object oriented programming capabilities for multiprocess coordination, interprocess communication, and resource management. Special attention is devoted also to metaprogramming as well, seen as a useful technique for specifying and building the operating environments of the languages themselves. The paper ends with a discussion on positive and negative features found comparing these languages, and indicates some guidelines to be followed in the design of new logic languages.     

Bridging the gap between tracking and detecting changes in XML

There are two main approaches to manage changes in XML documents, change‐tracking and diff. Change‐tracking tools, which record edit actions while they are performed on the source document, are able to capture the exact editing process. That is much more difficult for diff algorithms, which have to reconstruct it by comparing two different versions. Interestingly, these algorithms process both text‐centric and data‐centric XML documents the same way. In this paper, we show that more accurate, clear, and human‐readable results can be achieved on text‐centric resources, by employing specific models and algorithms. We describe and discuss a specialized diff algorithm for such a class of documents. We also compare a Java implementation of the algorithm, named JNDiff, with other general‐purpose or data‐oriented diff tools, focusing on the quality of their output. Copyright © 2014 Copyright © 2014 John Wiley & Sons, Ltd.     

Distributed programming with Logic Tuple Spaces

From the point of view of distributed programming one of the most interesting communication mechanisms is associative tuple matching in a shared dataspace, as exemplified in the Linda coordination language. Linda has been used as a coordination layer to parallelize several sequential programming languages, such as C and Scheme. In this paper we study the combination of Linda with a logic language, whose result is the language Extended Shared Prolog (ESP). We show that ESP is based on a new programming model called PoliS, that extends Linda with Multiple Tuple Spaces. A class of applications for ESP is discussed, introducing the concept of “open multiple tuple spaces”. Finally, we show how the distributed implementation of ESP uses the network version of Linda’s tuple space.     

Playing the perfect Kriegspiel endgame

Retrograde analysis is an algorithmic technique for reconstructing a game tree starting from its leaves; it is useful to solve some specific subsets of a complex game, for example a Chess endgame, achieving optimal play in these situations. Position values can then be stored in “tablebases” for instant access, in order to save analysis time, as is the norm in professional chess programs. This paper shows that a similar approach can be used to solve subsets of certain imperfect information games such as Kriegspiel (invisible Chess) endgames. Using a brute force retrograde analysis algorithm, a suitable data representation and a special lookup algorithm, one can achieve perfect play, with perfection meaning fastest checkmate in the worst case and without making any assumptions on the opponent. We investigate some Kriegspiel endgames (KRK, KQK, KBBK and KBNK), building the corresponding tablebases and casting light on some long standing open problems.     

Managing complex documents over the WWW: a case study for XML

The use of the World Wide Web as a communication medium for knowledge engineers and software designers is limited by the lack of tools for writing, sharing, and verifying documents written with design notations. For instance, the Z language has a rich set of mathematical characters, and requires graphic-rich boxes and schemas for structuring a specification document. It is difficult to integrate Z specifications and text on WWW pages written with HTML, and traditional tools are not suited for the task. On the other hand, a newly proposed standard for markup languages, namely XML, allows one to define any set of markup elements; hence, it is suitable for describing any kind of notation. Unfortunately, the proposed standard for rendering XML documents, namely XSL, provides for text-only (although sophisticated) rendering of XML documents, and thus it cannot be used for more complex notations. We present a Java-based tool for applying any notation to elements of XML documents. These XML documents can thus be shown on current-generation WWW browsers with Java capabilities. A complete package for displaying Z specifications has been implemented and integrated with standard text parts. Being a complete rendering engine, text parts and Z specifications can be freely intermixed, and all the standard features of XML (including HTML links and form elements) are available outside and inside Z specifications. Furthermore, the extensibility of our engine allows any additional notations to be supported and integrated with the ones we describe     

Using formal methods for teaching software engineering: a tool-based approach

In this paper we describe and review the course plan and syllabus we use in a course on formal methods in software engineering currently included in the degree in Informatics of the Faculty of Sciences at the University of Bologna. The course matches the theory of formal methods with their practice based on actual tool usage. In fact, the course is centered upon a project whose main goal is to let students learn some formal specification techniques, all supported by specific tools. The students use well-known notations for both requirements specification and formal design. The formal methods we use are based on the Z notation for requirements specification and on the Larch family of languages for design specifications.