We present our experiences in training computer science students in agile software development over two academic years. The product to build was a specialized Twitter client, with instructors refining its requirements throughout the course. We observed over a hundred students divided into teams of approximately five members each. To support agile collaboration and self-tracking, we provided students with a comprehensive software development environment consisting solely of opensource tools. Before commencing their cooperation, we encouraged students to engage in team-building activities to foster better mutual understanding. We adopted the Essence approach to instill an agile mindset and facilitated retrospectives tailored to the students’ needs. Key findings include the effective use of the adaptable Scrum framework with support from the Essence approach to agile teamwork. Although the constraint of using exclusively on-premises open-source software tools posed some challenges for the students, all produced data and documents were accessible for inspection by the instructors. Additionally, the utilization of a product quality model and team maturity model proved valuable for evaluating and comparing the teams. Notably, all teams successfully completed their tasks within the designated timeframe.

The paper we present [1] is an analysis of Cooperative Thinking, a model of team-based computational problem-solving that extends Computational Thinking with Agile Values.

The research examines the value and potential usefulness of using systemic thinking, which looks at the interconnectedness of things, to comprehend the complexities of software development projects and the technical and human factors involved. It considers two different aspects of systemic thinking - psychological and sociological - and posits that these can assist in understanding how software teams function and attain their objectives, as well as the goals of the entities for which they work. Our research aims to provide a novel contribution to the field by investigating the use of systemic thinking in software development teams and organizations. We evaluate the reliability and validity of the survey applied to different groups of relevant participants, relate our findings to existing literature, and identify the most representative factors of systemic thinking. Despite the popularity of various factors that fall under the umbrella of ’systems thinking’, there is limited understanding of their effectiveness in improving organizational performance or productivity, particularly when it comes to psychological and sociological systemic factors. The relationship between the use of systems thinking and organizational performance is often based on anecdotal evidence, rather than the identification and application of specific factors. Our work emphasizes the importance of understanding and applying such factors in order to build a solid foundation for the effective use of system dynamics and systems thinking tools, which is crucial for software development teams.

We present our plan to introduce Essence in our courses in software engineering, including a plan to evaluate our results and develop Essentialized tools.

Computational Thinking (CT) and Agile Values (AV) focus respectively on the individual capability to think algorithmically, and on the principles of collaborative software development. Although these two dimensions of software engineering education complement each other, very few studies explored their interaction. In this paper we use an exploratory Structural Equation Modeling technique to introduce and analyze Cooperative Thinking (CooT), a model of team-based computational problem solving. We ground our model on the existing literature and validate it through Partial Least Square modeling. Cooperative Thinking is new competence which aim is to support cooperative problem solving of technical contents suitable to deal with complex software engineering problems. This article suggests to tackle the CooT construct as an education goal, to train students of software development to improve both their individual and teaming performances.

Software-intensive systems work in ever-changing environments requiring expensive technical efforts to manage their evolution. In order to mitigate their risks and costs they should dynamically self-adapt to any modification of their environment. MAPE-K (Monitor, Analyze, Plan, Execute - Knowledge) is the basic architectural pattern for building software-intensive self-adaptable systems. In this paper we propose an approach in which all the information about a system and its environment is unified by using Semantic Web technologies into a set of semantic run-time models which enhance the Knowledge in MAPE-K. Ontologies are used to manage the interaction and integration of these models with disparate data sources. The resulting knowledge base is then used to drive adaptation activities exploiting well known languages and notations. We discuss how MAPE-K can be exploited in order to take advantage of ontological representations, along with Semantic Web languages and tools, by studying a real-word case study: a legacy system that was not designed to perform automatic adaptation. We discuss merits and limits of our approach based on semantic run-time models both in the context of this specific case study and in a broader scope.

Railway switches operate in harsh environmental conditions; still, their reliability requirements are high due to safety and economic factors. Once deployed, their maintenance depends on the data collected on their status, and the decisions on due corrective actions. The more regular this data collection and decision cycle is, the better confidence their operator has on effective and proper service. Proactive maintenance, in general, targets exactly this: rather than scheduling maintenance actions based on operating hours or servicing volume, actions should be taken when it is really needed. This requires the effective combination of data collection, analysis, presentation and decision making processes. The MANTIS project proposes a reference architecture for proactive maintenance, supported by the concept of cyber-physical systems. Besides suggesting data collection, processing and presentation methods and tools for this, the results were applied in various domains - including production systems, the energy grid, utility vehicles, or railways. The current paper presents data collection, analysis and presentation concepts related to proactive maintenance, applied on railway switches.

The Web and its Semantic extension (i.e. Linked Open Data) contain open global-scale knowledge and make it available to potentially intelligent machines that want to benefit from it. Nevertheless, most of Linked Open Data lack ontological distinctions and have sparse axiomatisation. For example, distinctions such as whether an entity is inherently a class or an individual, or whether it is a physical object or not, are hardly expressed in the data, although they have been largely studied and formalised by foundational ontologies (e.g. DOLCE, SUMO). These distinctions belong to common sense too, which is relevant for many artificial intelligence tasks such as natural language understanding, scene recognition, and the like. There is a gap between foundational ontologies, that often formalise or are inspired by pre-existing philosophical theories and are developed with a top-down approach, and Linked Open Data that mostly derive from existing databases or crowd-based effort (e.g. DBpedia, Wikidata). We investigate whether machines can learn foundational distinctions over Linked Open Data entities, and if they match common sense. We want to answer questions such as “does the DBpedia entity for dog refer to a class or to an instance?”. We report on a set of experiments based on machine learning and crowdsourcing that show promising results.

The need of handling semantic heterogeneity of resources is a key problem of the Semantic Web. State of the art techniques for ontology matching are the key technology for addressing this issue. However, they only partially exploit the natural lan- guage descriptions of ontology entities and they are mostly unable to find correspondences between entities having dif- ferent logical types (e.g. mapping properties to classes). We introduce a novel approach aimed at finding correspondences between ontology entities according to the intensional mean- ing of their models, hence abstracting from their logical types. Lexical linked open data and frame semantics play a crucial role in this proposal. We argue that this approach may lead to a step ahead in the state of the art of ontology matching, and positively affect related applications such as question an- swering and knowledge reconciliation.

Developing high quality software is a major industry concern, since programs that "just work" may not be suitable to contemporary technological challenges. Agile practices, such as Test-First development (TFD), may help in this direction. However, in our experience this technique is introduced late (if ever), when programmers' habits are already set and difficult to change. Early exposure to TFD in formal education could be an answer to that, but putting the principle into practice poses unexpected challenges. In this work we examine the short-and long-term impact of young programmers' exposure to TFD, highlighting its limits and proposing a reinforced teaching approach.

In this paper, we propose the Computational Thinking concept, which is obtained by enhancing by merging the values of Computational Thinking and Agile. We analyze four existing teaching models for training Cooperative Thinkers, supported by experimental data, and propose an educational path that can promote the early development of this complex skill.

Background Software systems are relying more and more on multi-core hardware requiring a parallel approach to address the problems and improve performances. Unfortunately, parallel development is error prone and many developers are not very experienced with this paradigm also because identifying, reproducing, and fixing bugs is often difficult. Objective The main goal of this paper is the identification of an approach able to: (i) identify solved concurrency-related bugs to characterize them and help retrospective activities; (ii) identify concurrency-related bugs as soon as they are entered in the bug management system to support bug triage phase and allocate them to more experienced developers. Approach To this end, the paper analyzes bugs related to concurrency looking at their specific characteristics using different machine learning methods to automatically distinguish them from other kinds of bugs based on the data available in the issue tracking systems and in the code repositories. Results The overall best models we developed for Apache HTTP Server and MariaDB have a precision of 0.985 and 0.814 and a recall of 0.876 and 0.629 when considering linked bugs (bug reports information in bug repository and the corresponding fix in the version control system) and a precision of 0.978 and 0.779 and a recall of 0.889 and 0.569 when considering only the information from bug reports. Conclusions Such results allow the development of an automated system able to classify such bugs and support developers in the bug triage process.

This paper proposes an adaptation to the open source environment (Linux Kernel and OpenSolaris) of a model for predicting which bugs get fixed in the Microsoft Windows operating system.We have analyzed the entire bug repositories containing 16,136 bug reports reported in about 8 years of activity of the project (from 2002 to 2010) for the Linux Kernel and 16,301 bug reports reported in about 3 years of activity of the project (from 2007 to 2010) for OpenSolaris.According to the data analyzed and the descriptive models produced, we have found that (a) bugs reported by people with better reputation and bugs in which more people are involved are more likely to get fixed, (b) reassigning or re-opening bugs are not affecting the fix likelihood, and (c) managing bugs in the same location increases the fix likelihood.The predictive model defined has a precision of 61% and a recall of 39% for the Linux Kernel and a precision of 76% and a recall of 73% for OpenSolaris.These results are comparable with the ones for Microsoft Windows.document.

Today's software systems increasingly work in changing environments, where rapid modifications in user needs, resource variabilities and system faults require remarkable administrative efforts. In order to mitigate the costs for governing these activities, software systems are expected to dynamically self-adapt. The problem of supporting auto-adaptation, which is complex activity in itself, is further exacerbated when applied to legacy systems which have not been developed for this purpose. In this paper we introduce a novel approach to self-adaptation based on the MAPE-K paradigm, where semantic models are used to provide an unified view of the heterogeneous elements composing these systems, and reasoning mechanisms are leveraged to drive adaptation strategies. We present the implementation of an adaptation engine based these concepts that uses ontologies and Semantic Web technologies, and discuss its application in a real world case study. From this experience, we offer recommendations for future research in this area.

Summary 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.

HPC software is developed and used in a wide variety of scientific domains including nuclear physics, computational chemistry, crash simulation, satellite data processing, fluid dynamics, climate modeling, bioinformatics, and vehicle development. The increase in the importance of this software motivates the need to identify and understand appropriate software engineering (SE) practices for HPC architectures. Because of the variety of the scientific domains addressed using HPC, existing SE tools and techniques developed for the business/IT community are often not efficient or effective. Appropriate SE solutions must account for the salient characteristics of the HPC, research oriented development environment. This situation creates a need for members of the SE community to interact with members of the scientific and HPC communities to address this need. This workshop facilitates that collaboration by bringing together members of the SE, the scientific, and the HPC communities to share perspectives and present findings relevant to research, practice, and education. A significant portion of the workshop is devoted to focused interaction among the participants with the goal of generating a research agenda to improve tools, techniques, and experimental methods regarding SE for HPC science.

We report on a recent experience in our Software Engineering laboratory course. More than one hundred students, from two different degrees, were divided in teams grouping diverse competences and skills, and had to develop four software products using a process model chosen among Waterfall, Spiral, and Extreme Programming. The two degrees involved were Computer Science and Informatics for Management. The former students have a standard, strong, background in programming, systems, and algorithms, while the latter students have a weaker training in programming compensated by some courses in Economics and Management. This situation allowed us to perform a double comparative study: on one hand, analyzing the laboratory results we obtained a comparison of the process models, which reproduced some results already known in literature. On the other hand we could compare “on the field” the different skills of students following different curricula, especially with respect to the requirements of the different process models. We discuss the results of this experience.

Software product line development refers to software engineering practices and techniques for creating families of similar software systems from a basic set of reusable components, called shared assets. Teaching how to deal with software product lines in a university lab course is a challenging task, because there are several practical issues that have to be solved in short time. In this paper we report an experience of ours, showing how in the context of a software engineering course at University of Bologna our students tackled the task of developing a software product line consisting of four products which were variants of a basic shared asset. The main idea is that the laboratory activities performed by our students followed the rules of a role-playing game. We describe this experience, defining the role-playing game by a meta-model which abstracts the notion of software process, and we show how we enacted the process for a software product line.

SUMMARY 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.

Kriegspielis a wargame based on the rules ofChess. In fact, the only difference betweenKriegspielandChessis that each player does not know his opponent's moves: the two players use different boards. A player only knows the position of his own pieces, while his opponent's pieces are invisible. A referee maintains the full state of the game on a third board. He answers a player's move attempt with information on its outcome, such as checks or piece captures. The referee also rejects illegal moves, forcing the player to try again. In this case, the player can exploit the negative information he received from the referee. AsKriegspielhas a very large state space and highly dynamic uncertainty, it is a very hard game for computers to play. In this paper, we focus on the simpler, but still difficult, task of playing the endgame. While manual algorithms have been developed to checkmate the lone King in various scenarios, they are often hard to translate into code, partially or ambiguously defined, and quite inefficient in the number of moves to mate. We describe a search algorithm for exploring theKriegspielendgames, and provide relatively simple evaluation functions able to progress through uncertainty. We show that our algorithm achieves quick checkmate in the vast majority of situations and significantly outperforms existing manual methods.

Plagiarism is a growing issue in the field of game-playing software. As new ideas and technologies are successfully implemented in free and commercial programs, they will be reused and revisited by later programs until they become standard, but on the other hand the same phenomenon can lead to accusations and claims of plagiarism, especially in competitive scenarios such as computer chess tournaments. Establishing whether a program is a "clone" or derivative of another can be a difficult and subjective task, left to the judgment of the individual expert and often resulting in a shade of gray rather than black and white verdicts. Tournaments judges and directors have to decide how similar is too similar on a case-by-case basis. This paper presents an objective framework under which similarities between game programs can be judged, using chess as a test case.

The importance of testing has recently seen a significant growth, thanks to its benefits to software design (e.g. think of test-driven development), implementation and maintenance support. As a consequence of this, nowadays it is quite common to introduce a test suite into an existing system, which was not designed for it. The software engineer must then decide whether using tools which automatically generate unit tests (test suites necessary foundations) and how. This paper tries to deal with the issue of choosing the best approach. We will describe how different generation techniques (both manual and automatic) have been applied to a real case study. We will compare achieved results using several metrics in order to identify different approaches benefits and shortcomings. We will conclude showing the measure how the adoption of tools for automatic test creation can shift the trade-off between time and quality.

Abstract In the context of the progressive incarnation of Grid systems in terms of a Service Oriented Architecture, it is essential to improve the automatic evaluation and selection of Grid services. Current mechanisms for service evaluation lack expressiveness as regards the representation of service requesters' expectations. In this paper, we present a model for the quantitative expression of service attributes, for the association of the possible values of these attributes with the requester satisfaction and for the aggregation of a set of satisfactions in an overall score by means of different aggregation logics. The proposed approach enriches the expressiveness of the mechanisms for the evaluation of Grid services. Copyright © 2005 John Wiley & Sons, Ltd.

The education of software engineers more and more addresses organizational and management issues, like for instance modeling the business structure and environment which will receive a new software system. The teaching to software engineering students of modeling technologies based on standards like UML and the Rational Unified Process, stressing the focus on designing business-oriented management of software services, raises novel questions than need to be addressed.

In the linking model of the World Wide Web each link is stored in the referring document within an attribute of the A tag. All the hyperlink defined this way can reference a single resource or a single fragment. With the evolution of Web technologies more powerful linking languages (XLink and XPointer) have been proposed.Here we introduce XLinkProxy, a Web application that allows sophisticated hyperlink (defined using XLink and XPointer) to be defined outside referring documents, giving users the chance to build dynamic multidestination, multidirectional links databases.

Software components can give rise to several kinds of architectural mismatches when assembled together in order to form a software system. A formal description of the architecture of the resulting component-based software system may help to detect such architectural mismatches and to single out the components that cause the mismatches. In this article, we concentrate on deadlock-related architectural mismatches arising from three different causes that we identify: incompatibility between two components due to a single interaction, incompatibility between two components due to the combination of several interactions, and lack of interoperability among a set of components forming a cyclic topology. We develop a process algebra-based architectural description language called PADL, which deals with all three causes through an architectural compatibility check and an architectural interoperability check relying on standard observational equivalences. The adequacy of the architectural compatibility check is assessed on a compressing proxy system, while the adequacy of the architectural interoperability check is assessed on a cruise control system. We then address the issue of scaling the architectural compatibility and interoperability checks to architectural styles through an extension of PADL. The formalization of an architectural style is complicated by the presence of two degrees of freedom within the set of instances of the style: variability of the internal behavior of the components and variability of the topology formed by the components. As a first step towards the solution of the problem, we propose an intermediate abstraction called architectural type, whose instances differ only for the internal behavior of their components. We define an efficient architectural conformity check based on a standard observational equivalence to verify whether an architecture is an instance of an architectural type. We show that all the architectures conforming to the same architectural type possess the same compatibility and interoperability properties.

Formalizing the description of software systems helps to detect the presence of architectural mismatches that can arise when assembling software components together. The authors identify three causes of architectural mismatches: incompatibility between two components due to a single interaction, incompatibility between two components due to the combination of several interactions, and lack of interoperability among a set of components forming a cyclic topology. We then show how to deal with all of them within a uniform, process algebraic framework. We begin with the first two causes by strengthening a previously defined architectural compatibility check based on observational equivalences, in order to achieve a deadlock freedom result for the set of components interacting via a certain connection. We subsequently concentrate on the third cause by defining a novel architectural interoperability check based on observational equivalences, which guarantees absence of deadlock within a set of interacting components forming a cyclic topology. We finally assess the adequacy of our architectural interoperability check by applying it to the description of a cruise control system.

In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.

No abstract available.

Architectural styles play an important role in software engineering as they convey codified principles and experience which help the construction of software systems with high levels of efficiency and confidence. We address the problem of formalizing and analyzing architectural styles in an operational setting by introducing the intermediate abstraction of architectural type. We develop the concept of architectural type in a process algebraic framework because of its modeling adequacy and the availability of means, such as Milner's weak bisimulation equivalence, which allow us to reason compositionally and efficiently about the well formedness of architectural types.

New computing paradigms for network-aware applications need specification languages able to deal with the features of mobile code-based systems. A coordination language provides a formal framework in which the interaction of active entities can be expressed. A coordination language deals with the creation and destruction of code or complex agents, their communication activites, as well as their distribution and mobility in space. We show how the coordination language PoliS offers a flexible basis for the description and the automatic analysis of architectures of systems including mobile entities. Polis is based on multiple tuple spaces and offers a basis for defining, studying, and controlling mobility as it allows decoupling mobile entities from their environments both in space and in time. The pattern-matching mechanism adopted for communication helps in abstracting from addressing issues. We have developed a model-checking technique for the automatic analysis of PoliS specifications. In the article we show how this technique can be applied to mobile code-based systems

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.

The original Web did not support multiuser, interactive applications. This shortcoming is being studied, and several approaches have been proposed to use the Web as a platform for programming Internet applications. However, most existing approaches are oriented to centralized applications at servers, or local programs within clients. To overcome this deficit, we introduce PageSpace, that is a reference architecture for designing interactive multiagent applications. We describe how we control agents in PageSpace, using variants of the coordination language Linda to guide their interactions. Coordination technology is integrated with the standard Web technology and the programming language Java. Several kinds of agents live in the PageSpace: user interface agents, personal homeagents, agents that implement applications, and agents which interoperate with legacy systems. Within our architecture, it is possible to support fault-tolerance and mobile agents as well.

Currently, the Web does not support distributed applications well. Existing approaches are oriented towards centralized applications at servers, or local programs within clients. To overcome this deficit, the PageSpace platform was designed for distributed, coordinated agents in the Web. We take a specific approach to coordinate agents in PageSpace applications, namely variants of coordination language Linda that support rules and services to guide their cooperation. This technology is integrated with the standard Web technology and the language Java. Several kinds of agents live in the PageSpace: user interface agents, personal home agents, the agents that implement applications, and the kernel agents of the platform. Within the architecture it is possible to support fault tolerance and mobile agents as well.

The use of formal methods early in the development process has been advocated as a way of improving the quality of software products and their production process. Here we study the influence of a formal requirements document on the next phase in the software process, that is design. We suggest that formal design should coherently follow from formal requirements. We show that two different formal notations can be effectively used, one for writing requirements specification and one for design specification. We also consider how a design specification can be formally checked with respect to requirements specification. The notations we choose are well known: the Z notation for requirements and the Larch two-tiered language for design. We show how a number of tools based on these notations can be used to improve the quality of the documents produced during the development process.

An impediment to the widespread use of formal methods for software development is the difficulty in dealing with specifications, namely using them consistently in the software process. One approach to easing the management of specifications and improving their impact in the software process is animation, allowing developers to “execute” formal specifications as prototypes. This paper illustrates how Prolog can serve a multifaceted role for animating and prototyping specifications—as a target language, as the compilation/translation language, and to facilitate the advantages of formal methods through help in building formal proofs of properties such as correctness. Further, there is an implicit claim that, because of the correctness and directness of the translation, a subset of Z, not definitively established here, can be viewed as equivalent to a subset of Prolog.

Abstract 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.

ESP is a language for modeling rule-based software processes that take place in a distributed software development environment. It is based on PoliS, an abstract coordination model that relies on Multiple Tuple Spaces, i.e., collections of tuples a la Linda. PoliS extends Linda aiming at the specification and coordination of logically distributed systems. ESP (Extended Shared Prolog) combines the PoliS mechanisms to deal with concurrency and distribution, with the logic-programming language Prolog, to deal with rules and deduction. Such a combination of a coordination model and a logic language provides a powerful framework in which experiments about rule-based software process programming can be performed and evaluated.

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

Shared Prolog is a new concurrent logic language. A Shared Prolog system is composed of a set of parallel agents that are Prolog programs extended by a guard mechanism. The programmer controls the granularity of parallelism, coordinating communication and synchronization of the agents via a centralized data structure. The communication mechanism is inherited from the blackboard model of problem solving. Intuitively, the granularity of the logic processes to be elaborated in parallel is large, while the resources shared on the blackboard can be very fined grained. An operational semantics for Shared Prolog is given in terms of a distributed model. Through an abstract notion of computation, the kinds of parallelism supported by the language, as well as properties of infinite computations, such as local deadlocks, are studied. The expressiveness of the language is shown with respect to the specification of two classes of applications: metaprogramming and blackboard systems.

The parallel logic language Shared Prolog embeds Prolog as its sequential component. A program is Shared Prolog is composed of a set of logic agents, i.e. Prolog programs, that communicate associatively via a shared workspace called blackboard.