Typically, multiple developers are involved in the various stages of the software development and maintenance process. To ensure an optimal transfer of knowledge between these different peers, a reliable human-readable model of the dynamics of a software artefact is needed. Once these models become machine-verifiable, they can be used throughout an application’s lifetime to check whether the documented behavioral properties continue to hold as the application evolves. Unfortunately, most existing modeling media are inadequate to express human-readable behavioral models which are at the same time machine-verifiable. We therefore propose a declarative platform wherein behavioral program models can be expressed in terms of userdefined high-level concepts and be automatically verified against an application’s actual behavior. We demonstrate our approach by using it to both document and verify an interpreter for a garbage-collected programming language. 1.

A new field in distributed computing, called Ambient Intelligence, has emerged as a consequence of the increasing availability of wireless devices and the mobile networks they induce. Developing software for such mobile networks is extremely hard in conventional programming languages because the network is dynamically defined. This hardware phenomenon leads us to postulate a suite of characteristics of future Ambient-Oriented Programming languages. A simple reflective programming language kernel, called AmbientTalk, that meets these characteristics is subsequently presented. The power of the reflective kernel is illustrated by using it to conceive a collection of high level tentative ambient-oriented programming language features.

In the emerging field of Ambient Intelligence (AmI), software is deployed in wireless open networks of mobile devices. Such open networks require stringent security measures as unknown and untrusted hosts may join the network. In an object-oriented language, where objects are distributed and moved across the network, it thus becomes important to be able to enforce object encapsulation. In contemporary object-oriented programming languages, powerful operations such as object extension (inheritance), cloning and reflection, are typically provided via omnipotent language operators that fail to uphold object encapsulation, because they can be applied without the explicit consent of the concerned object. This paper formulates a language design principle –extreme encapsulation– that precludes the use of such harmful operators, and proposes a corresponding language feature –method attributes – that makes it possible to provide the flexibility of object extension, cloning and reflection without compromising on object encapsulation. Although some existing object-based languages can be said to support extreme encapsulation, our contribution is to support it in a delegation-based, prototype-based language named ChitChat. 1.

Testing is a crucial part of the software development life cycle that necessitates adequate techniques and tools. On the one hand, unit or function testing techniques are particularly easy and lightweight to use but are restricted to the testing of the external behaviour of a program. On the other hand, testing techniques that use property-driven models of the software are able to test behavioural properties of the entire execution of a program. However these models are often specified in terms of low-level execution events of the program. In this paper, we present the lightweight propertydriven testing platform called BEHAVE, where tests are written as property-driven behavioural models over highlevel run-time events. We validate our approach by testing behavioural properties related to the automatic memory management in the interpreter of the Pico programming language. 1.

Moderne softwaresystemen zijn dikwijls zo complex dat ze niet slechts één probleem oplossen maar zich toespitsen op het oplossen van fundamenteel verschillende deelproblemen. De ervaring van de laatste decennia leert ons dat niet alle programmeerproblemen op expressieve wijze met eenzelfde taal opgelost kunnen worden. Programmeurs zijn productiever wanneer zij de taal gebruiken die het best geschikt is voor het oplossen van het probleem dat zich voordoet. Maar in het grotere geheel van een softwaresysteem zullen deze delen die in verschillende talen ontwikkeld zijn, uiteindelijk moeten samenwerken. Om die reden zijn er verschillende technieken ontwikkeld om zulke taalinteroperabiliteit te bekomen. Sommige van deze technieken zijn ontwikkeld om de betrokken talen zo nauw mogelijk met elkaar te laten samenwerken, zodat eigenschappen van de ene taal op een transparante manier in de andere taal gebruikt kunnen worden, zodanig dat zij in een taalsymbiose verkeren. Programmeertalen worden onderverdeeld in programmeerparadigma’s,

Abstract not found