This article describes how an experimental platform for social, mobile and ubiquitous computing has been used in a wide-ranging longitudinal “in the wild” case study of the platform with a set of third-party services. The article outlines some of the relevant aspects of the platform, including built-in support for community formation, for context sensitivity, automated learning and adaptation to the user, and for management of privacy and trust relationships. The platform architecture is based on the notion of Cooperating Smart Spaces (CSSs), where a CSS is a partition of the platform corresponding to a single user and distributed over the devices belonging to that user. Three of the case study services were intended for use in a physical environment specifically created to support ubiquitous intelligence; they were highly interactive and used shared screens, voice input and gestural interaction. Another three ubiquitous services were available throughout the university environment as mobile and desktop services. The case study exploited this architecture's ability to integrate multiple novel applications and interface devices and to deliver them flexibly in these different environments. The platform proved to be stable and reliable and the study shows that treating a provider of services and resources (the University) as a CSS is instrumental in enabling the platform to provide this range of services across differing environments.

Personalization mechanisms often employ behavior monitoring and machine learning techniques to aid the user in the creation and management of a preference set that is used to drive the adaptation of environments and resources in line with individual user needs. This article reviews several of the personalization solutions provided to date and proposes two hypotheses: (A) an incremental machine learning approach is better suited to the preference learning problem as opposed to the commonly employed batch learning techniques, (B) temporal data related to the duration that user context states and preference settings endure is a beneficial input to a preference learning solution. These two hypotheses are the cornerstones of the Dynamic Incremental Associative Neural NEtwork (DIANNE) developed as a tailored solution to preference learning in a pervasive environment. DIANNE has been evaluated in two ways: first, by applying it to benchmark datasets to test DIANNE's performance and scalability as a machine learning solution; second, by end-users in live trials to determine the validity of the proposed hypotheses and to evaluate DIANNE's utility as a preference learning solution.

One of the key objectives of a pervasive computing system is to provide appropriate support to enable the user to manage the increasingly complex environment surrounding her. This includes managing the ever-increasing number of devices which can be accessed wirelessly as well as the vast range of services at her disposal. The aim of the Persist project was to develop a pervasive system that would bridge the gap between fixed smart spaces (e.g. smart homes) and systems created for mobile users. Using the concept of Personal Smart Spaces the Persist project has built a prototype system to demonstrate some of the capabilities that this can provide. The Societies project is currently building on these ideas to develop a new type of system that combines pervasive with social networking functionality. Personalisation is an essential feature of any pervasive system and plays a key role in the prototype implemented in Persist. This will also play a key role in the new platform being developed in the Societies project. This paper describes how personalisation is handled within the Persist system and some ideas for the new platform.

A major research challenge in the IT domain nowadays is to enable new experiences by building intelligent spaces around users, enhanced by pervasive computing services. The European FP7 Project PERSIST (personal self-improving smart spaces) is investigating a novel approach to meet this challenge. PERSIST aims to define an ecosystem on top of which novel pervasive services can be built. This paper explains the notion of a personal smart space (PSS), provides a reference case study and describes some aspects of how PSSs might operate. PERSIST is also researching on new paradigms for harmonizing P2P functionalities with network services. We present a case study and bring into focus the main challenges We are mastering for pursuing a middleware to support PSSs management and mutual interaction.

Current pervasive environments should contain mechanisms, such as personalization, that adapt the environment to help the user meet their individual needs. However, manually creating, maintaining and utilizing a preference set is no easy task for a user, requiring continued time and effort. A more desirable approach is to implicitly build and maintain the preference set by using monitoring and learning mechanisms and apply such preferences when required on behalf of the user. This paper introduces the Daidalos Personalization and Learning system which monitors user behaviour and context to not only build and maintain dynamic preferences but also to apply them in a dynamic fashion. An example scenario is presented to demonstrate how such mechanisms are used to adapt a pervasive environment on a user¿s behalf.

User preferences have an important role to play in decision making in pervasive systems, and most systems incorporate some form of preferences, albeit that different forms and approaches are used in different implementations. It is generally accepted that user preferences need to be context-dependent, although the process of applying user preferences to personalize decision taking in the system tends to be treated as a static process that is carried out at the outset when a service is started and not referred to again unless the user specifically instructs a change. However, there are situations where a more dynamic approach to dealing with user preferences is called for. This has been investigated as part of the Daidalos pervasive system, and this paper reports on the approach used and implemented in this system.

Two important concepts in developing ubiquitous or pervasive computing technologies that are acceptable to the end user are personalization and privacy. On the one hand it is essential to take account of user needs and preferences to personalize decision making within such a system, on the other hand it is equally important to protect user privacy. One approach to handling user privacy is through the use of virtual identities. This has the advantage that it can also benefit the handling of user preferences. In particular, virtual identities can be used as a substitute for roles. On the other hand user preferences can be used in identity management to assist in selecting a virtual identity to hide the real identity of the user, thereby improving user-friendliness of the system. This paper describes this symbiosis and how it is implemented in the Daidalos pervasive system.

An important aspect of a pervasive environment is that it needs to support mobile users - i.e. users whose context changes frequently. In doing so it is important to take account of a user's context in adapting and personalizing services for the user. This paper describes a personalization mechanism that is exploited in the Daidalos project to provide users with value-added enhanced services. It personalizes services across layers including networking and service layers.

With the explosion in the availability of information online, users are finding it increasingly difficult to track down the specific material that they require. Users are therefore becoming increasingly dependent on intelligent services to provide information that is dynamically selected and presented according to their preferences. However, development of these personalized services is not trivial. Significant effort is required in terms of engineering the underlying knowledge that is used by a service to determine which information might be relevant to a particular user and how to present it. A Toolkit that reduces the complexity involved in the creation and maintenance of such services is discussed.

Universal access to information and data is an important goal of current research. Previously different forms of information and data, captured by different devices or held on different systems, were isolated. However, the development of different networks has created the "glue" by which the overall goal of universal access can be achieved. Another important goal is the development of personalized information and communication systems in which the user has increasing control over access to and presentation of information and data. The current challenge is to bring these two ideas together into integrated systems. This paper investigates a personalized communication system that is able to intercept, filter, convert and direct communications and data, thereby giving the user control over the delivery and presentation of information. Such a system must provide flexible and intuitive mechanisms whereby users can specify their preferences and control access to and presentation of information and data. It must cater for user mobility, and handle routing and data conversion. The need for these components is motivated by using an example scenario to derive the design requirements for the architecture. The implementation technology of components of the architecture is described briefly.

The Internet and associated technology is transforming the dissemination of healthcare information. As this occurs, means must be developed to manage and coordinate it effectively. One approach is through community healthcare information networks (CHINs), which benefit both information providers and consumers. This paper reports on a regional CHIN operational in Scotland.

This paper describes a study of different approximation techniques used to predict the response times of database transactions represented as patterns of resource consumption and modelled with non-product-form queueing networks. The techniques are applied to a range of examples. The experiments show that none of the approximation techniques has a consistent advantage over the others for all cases considered. On the other hand, a simple heuristic rule is formulated which provides an acceptable approximation to the average transaction response time for the entire range of examples. The rule specifies a procedure for labelling each queue in a queueing network as either an M/M/1 or an M/G/1 resource. The resulting network can then be solved to obtain the mean response time of individual transactions.

The uptake of parallel DBMSs is being hampered by uncertainty about the impact on performance of porting database applications from sequential to parallel systems. The development of tools which aid the system manager or machine vendor could help to reduce this problem. This paper describes an analytical tool which determines the performance characteristics (in terms of throughput, resource utilisation and response time) of relational database transactions executing on particular machine configurations and provides simple graphical visualisations of these to enable users to obtain rapid insight into particular scenarios. The problems of handling different parallel DBMSs are illustrated with reference to three systems – Ingres, Informix and Oracle. A brief description is also given of two different approaches used to confirm the validity of the analytical approach on which the tool is based. Copyright © 1999 John Wiley & Sons, Ltd.

ROCK & ROLL is a deductive object oriented database system that supports two languages, one imperative and the other deductive, both derived from the same object oriented data model. As the languages share a common type system, they can be integrated without manifesting impedance mismatches, and thus programmers can conveniently exploit both deductive and imperative features in a single application. The components of ROCK & ROLL are as follows: data model OM-OM supports a range of conventional modelling constructs, such as sets, sequences, aggregations and (both single and multiple) inheritance; deductive language ROLL-ROLL is a conventional first order deductive database language, which differs from Datalog with negation in being strictly typed (through type inference), having a structured clause base that associates rules with classes, and in that the extensional database is that of OM, rather than the relational model; and imperative language ROCK-ROCK is a conventional imperative object oriented programming language, with facilities for creating and manipulating OM objects, iteration, I/O, etc. The use of two languages has allowed us to keep the logic language ROLL simple, as facilities such as updates are not handled within ROLL, but rather in the closely integrated imperative language ROCK. The basic ROCK & ROLL system provides comprehensive modelling and programming facilities, but recent work has extended it with both active rules and spatial data types.

Cache modelling is an important issue in developing an analytical performance evaluator to estimate the performance of applications running on parallel DBMSs. This paper describes a cache model developed for parallel cache management in the Oracle7 parallel server. Some preliminary results have also been obtained by using the cache model to predict the cache hit ratio for varying database sizes and varying numbers of participating processing elements.

This paper presents a framework for the formal specification of active database systems, and shows how the framework can be used to describe the functionality of three well known example systems, namely Starburst, POSTGRES and Ariel. The framework has been developed using Object-Z to structure specifications in a way that emphasises commonalities and key differences between the designs, and that is readily extensible to support new constructs and systems. Such a formal framework can be used to provide formal descriptions of systems that have previously been described only informally, to compare the functionalities of different systems by contrasting support for fundamental concepts, and as a basis for reasoning about rule bases in the context of different active rule systems. The paper also demonstrates the applicability of object-oriented formal methods to the specification of advanced database functionality.

A new form of database integrity constraint is introduced which describes the structure present in data when that structure takes the form of a graph, tree or list. This type of integrity constraint is of particular benefit in reducing the overhead when detecting termination in the case of recursive queries.

One of the problems facing the designers of a deductive database is that of the choice of query language. The deductive database model is seem as a natural progression from the relational model; the query language should reflect this. This paper reports the decisions taken while designing an extended form of SQL, called SQUIRREL, as the query language for a Prolog-based deductive database. The extensions relate to the inclusion of both rules and incomplete information in the query language and result in changes to the data definition, data manipulation and query languages of SQL. The extensions were constrained by the desire to retain the existing SQL texture in the new language while introducing concepts such as rules, rule manipulation and incomplete information which are alien to the relational philosophy. The language we describe is being used as the interface language for an implementation of a deductive database which will run on a version of Prolog developed to handle database applications.

Whereas existing Prolog systems are very effective at handling small knowledge bases, they are not very efficient at and often incapable of handling large sets of clauses. Large knowledge bases which may comprise millions of clauses and are shared by a number of users, may need to reside in secondary memory. In such cases exhaustive search is inordinately slow. Various approaches have been put forward for handling the problem, most of which involve coupled systems (loosely or tightly coupled). A Prolog data/knowledge based system which provides an integrated solution to the problem is being developed. An essential element in this system is the CLAuse Retrieval Engine, CLARE, which is a special purpose hardware engine designed to perform selective retrieval of data from disk in order to identify all potential clauses which will be required for full unification during a query. The engine consists of two separate hardware components, which together form a two-stage filtering configuration. This paper concentrates on the second stage filter which is concerned with partial test unification.

In a database missing values may be denoted by the use of a special null symbol. However, between the extremes of complete information and missing information one may have various states of incomplete or partial information. One of the advantages which logic databases will have over relational databases is the ability to handle incomplete information in a more helpful way than simply through the use of null values. This paper considers three forms of incomplete information and describes how the query language Query-by-Example can be extended to cater for these forms. The implementation of these ideas in Prolog is described to illustrate how these concepts can be realised in a logical programming language.

One of the objectives of the Japanese Fifth Generation Computer Project is to develop computer systems whose kernel languages are based on logic programming rather than on the conventional imperative languages which have been in general use until now. This has led to conjecture about the problem of the large base of existing software which is implemented in imperative languages. To this end a study has been conducted into the possibility of translating programs written in Pascal-S into Prolog. Because of the radically different control and data structures in these two languages, the translation process is not straightforward. The problems associated with this process are discussed and its performance assessed.

One of the most important elements of an internal control system is the segregation of incompatible functions. Essential to this process is the task of identifying the sets of functions which are incompatible. Once these have been determined the access capabilities (both direct and indirect) of each individual or group in the organisation must be traced to ensure that no person has access to a set of incompatible functions. The logic programming language Prolog can be used to assist in this process.

A linear algorithm for colouring planar graphs with at most five colours has recently been published. However, this algorithm, which operates by recursive reduction of the graph, is unnecessarily complicated. An alternative method which is much simpler is presented in this paper.

The two-level grammar notation is a powerful tool for specifying the syntax, static semantics and even dynamic semantics of programming languages. However, it can also be a very difficult notation to follow. For this reason an approach to writing two-level grammars is advocated which explicitly indicates the ‘direction of propagation’ of metanotions. This suggests the requirement that the direction of propagation of each metanotion within a given hypernotion should be consistent and enables one to test a two-level grammar specification for circularity.

Besides their bad influence on programming style, the presence of goto statements in a program can complicate considerably the problem of mechanical translation into another programming language. In view of this an algorithm is presented which will restructure any Pascal program which contains goto statements to produce an equivalent program without goto statements. A system using this algorithm has been developed in Prolog.

Dans cet article, on decrit un ensemble de graphes planaires 6000 qui a ete genere en utilisant des techniques differentes. Chaque graphe a entre 20 et 200 sommets. Ils sont utilises pour comparer la performance de 10 algorithmes de coloration. Les resultats montrent clairement l'avantage des algorithmes de reduction pour la coloration des graphes planaires

The problem of nomenclature (different names being used to refer to the same object or idea, and the same name being used to refer to different objects and ideas) plaques many areas of Computer Science. The theory of flowchart schemata is no exception to this. This paper attempts to clarify some of the issues concerned with reducibility and structuredness in flowchart schemata.

BPL is a programming language which was developed from the two languages BASIC and Pascal. The chief aim in designing BPL was to create a language as simple to use as BASIC with the additional data types and control structures which make Pascal attractive to use. It is intended in the first instance as a language to teach programming but it can be used for any application where BASIC might have been used, and in many such cases it is simpler to use and the result more readable than if BASIC had been used. For instance, the record facilities make the language more amenable to commercial applications, and the pointer facilities to manipulating complex linked data structures.

A recent paper by Prather and Giulieri raises two issues. The first concerns the pre-processing of flowcharts before attempting to isolate unstructured subflowcharts, and a modification to the principle of collapsibility defined by Hecht is introduced as an aid in this regard. The second concerns the concept of dominance and the algorithms which Prather and Giulieri present for determining subflowcharts.

Abstract The researcher who knows little about computers but wants to conduct a survey and analyse the results by computer can land himself in some difficulty if he does not appreciate some of the problems of computerization. This paper describes a system which is designed to aid such a person by providing assistance with the design of the questionnaire, the capturing of the data and the final analyses.

Syntactic DefinitionsIn view of the proliferation of notations for defining the syntax of programming languages, it has been suggested that a simple notation should be adopted as a standard.However, any notation adopted as a standard should also be as versatile as possible.For this reason, a notation is presented here which is both simple and versatile and which has additional benefits when specifying the static semantic rules of a language.

The extended operator precedence method of parsing described by Henderson and Levy (1976) will only work correctly provided the grammar used satisfies certain conditions. The conditions which they proposed are, however, incorrect and a revised set of conditions are put forward here.

Abstract In a number of computer systems an instruction in symbolic assembly language may be translated as either a long form or a short form instruction in machine code depending on certain conditions. Assemblers which optimize the size of a program by using short form instructions wherever possible, sometimes require three or more passes to achieve this. This paper describes an approach to solving this type of problem which can be implemented in a two‐pass or even a one‐pass assembler.

The static semantic rules of ALGOL60 and BASIC are expressed in a formal notation to demonstrate that the notation can be used for such languages. This is seen as an aid to both the compiler writer and the user, partly in that the intentions of the language designer can be communicated clearly and unequivocally and partly in that the specification may be used as a guide to producing a correct compiler or in verifying the correctness of a compiler.

A system for automatically generating programs for a particular class of problem – in this case the class of payroll problems – is discussed. The technique used in the generation process is based on the stepwise refinement approach to problem solving. The method described is applicable to other similar problems and ultimately could be used in a general automatic programming system.

Various workers have suggested methods for converting unstructured flow diagrams into equivalent structured ones. Some of these are compared here and a general method for performing such a conversion is discussed.

Abstract Formal notations for the specification of the syntax and the dynamic semantics of languages exist and are of great benefit to the compiler writer. However, formal notations for the static semantics of languages have tended to be tools of the language designer and of little practical significance to the compiler writer. This paper describes how a particular notation was used to assist in the implementation of a Cobol compiler and of an interpreter for a simulation language.

Various methods have been put forward by different authors for converting an ‘unstructured flow diagram’ into an equivalent ‘structured’ one. This paper examines the basic flow diagram sub-structures, the presence of which in a flow diagram causes the flow diagram to be unstructured, and proves that these are the only structures which lead to unstructuredness.

Abstract Since Cobol is essentially a byte‐oriented language, certain practical problems arise when implementing it on a word‐oriented machine. The particular problem of handling arrays with SYNCHRONIZED clauses is discussed here and a method put forward for solving it.

This paper describes a computer simulator which is used as an aid to teaching certain aspects of computer science. The properties of the computer to be simulated are determined by parameters which are read in as data by the simulator. Once these are set up, further parameters are used to enter a program coded in the machine code of the simulated computer. The program will be executed with monitor printouts of specified registers or portions of memory.