Abstract not found

Many modern parallel languages support dynamic creation of threads or require multithreading in their implementations. The threads describe the logical parallelism in the program. For ease of expression and better resource utilization, the logical parallelism in a program often exceeds the physical parallelism of the machine and leads to applications with many fine-grained threads. In practice, however, most logical threads need not be independent threads. Instead, they could be run as sequential calls, which are inherently cheaper than independent threads. The challenge is that one cannot generally predict which logical threads can be implemented as sequential calls. In lazy multithreading systems each logical thread begins execution sequentially (with the attendant effic...

Fall 2000. However it is still possible to generate a non-conformant document if the published instructions are not followed! Be sure to refer to the published Graduate School guidelines as well. This summary page can be disabled by specifying the nosummary option to the class invocation.(i.e., \documentclass[nosummary]{ndthesis})

. We propose a standard level of support for nomadic computing in which a mobile client can move into unfamiliar environments and obtain services for which it has no corresponding client RPC stub. We call this activity service discovery and motivate its importance for mobile computing. This paper describes the general components of service discovery and points out where traditional paradigms of distributed computing fall short of its requirements. We suggest an architecture for an environment which uses SLIP or PPP over modem connections, a directory service based on the ODP trading function, and a dynamic interface mechanism for ad hoc client-server interaction. 1.0 Introduction The goal of nomadic computing transcends simply making one's environment portable; mobile users require the ability to communicate with local servers despite location and the ability to obtain local services despite statically defined service interfaces. To this end, we expect the portable computer or PDA to ...

Concurrent programming has two main benefits: First, it allows natural solutions to software design problems that are inherently parallel or distributed. Second, concurrent programs offer better efficiency than sequential programs. However, concurrent programming poses many challenges that do not exist in the sequential setting. For instance, the processes in the system may livelock, diverge, or even deadlock. The Java Remote Method Invocation (RMI) package facilitates the implementation of concurrent applications in which, for instance, the processes reside on different hosts and communicate over the internet. More precisely, it hides the details of network communication. Unfortunately, it does not relieve the programmer from the potential pitfalls of controlling the concurrent access to remote objects. Consequently, RMI applications are prone to the same problems as concurrent programs in general.

OFL (Open Flexible Languages) is the name of a meta-model for object-oriented programming languages based on classes. It relies on three essential concepts of these languages: the descriptions which are a generalisation of the notion of class, the relationships such as inheritance or aggregation and the languages themselves. OFL provides a customisation (hyper-genericity) of these three concepts in order to adapt their operational semantics to the programmer’s needs. So, at first reading the OFL approach can be summed up as the search for a set of parameters whose value determines the operational semantics of an object-oriented language based on classes. One of the main goals of OFL is to describe existing object-oriented languages such as Java [Fla99, GJSG00], Eiffel [Mey97], or C++ [Str97] in order to be able to extend them according to two directions. On the first hand, we want to extend the language itself by adding new concepts and more especially new inter-classes relationships (like a multiple inheritance relationship in Java) [CCL01]. On the other hand, we wish to extend the language with new orthogonal services (for example persistent object handling). In this paper we focus on the second direction. When designing and programming applications, people often need additional services in order to handle object evolution, persistence, distribution of data, etc. One of the most interesting approach is to use aspectoriented

The Hippo project is an investigation into the use of high-level programming paradigms in the context of global computation. The intention is to discover abstractions which allow global applications to be written by an average applications programmer, rather than a specialist in networked computer systems. This will be achieved by the combination of the provision of highlevel semantic constructs which can describe useful behaviour patterns within the global computer network, and abstraction over unnecessary low-level detail of the communication protocols. This paper gives only a high-level overview of the project's aims and objectives. Although at an early stage of research, many more technical issues and partial solutions have been identified which are not described here due to a lack of space.

To implement a system for the declarative programming of interactive applications, such that these applications may be presented as GUIs, or represented in other ways. This is to be done without allowing applications to perform actions on global system state. Work Completed The system was implemented. Several targets were written, including a GTK GUI target, a GDK graphics target, a web target and a file target. This allows simple programs to be written and run, and targetted at different runtime environments.