Abstract: In this paper we present the Molen programming paradigm, which is a sequential consistency paradigm for programming Custom Computing Machines (CCM). The programming paradigm allows for modularity and provides mechanisms for explicit parallel execution. Furthermore it requires only few instructions to be added in an architectural instruction set while allowing an almost arbitrary number of op-codes per user to be used in a CCM. A number of programming examples and discussion is provided in order to clarify the operation, sequence control and parallelism of the proposed programming paradigm.

Abstract: Because threads are a core feature of the Java language, the widespread adoption of Java has exposed a much wider audience to concurrency than previous languages have. Concurrent programs are notoriously difficult to write correctly, and many subtle bugs can result from incorrect use of threads and synchronization. Therefore, finding techniques to find concurrency bugs is an important problem. Through development and use of an automatic static analysis tool, we have found a significant number of concurrency bugs in widely used Java applications and libraries. Interestingly, we have found that race conditions abound in concurrent Java programs; underuse of synchronization is the rule rather than the exception. We have also found many examples of other kinds of concurrency errors, suggesting that many Java programmers have fundamental misconceptions about how to write correct multithreaded programs. This paper makes two main contributions. First, it describes simple analysis techniques that are effective at finding concurrency errors in real programs. Second, it provides evidence that threads and concurrency are widely misused in Java, even in programs written by experienced programmers.

Abstract: In this paper, we describe ChucK - a programming language and programming model for writing precisely timed, concurrent audio synthesis and multimedia programs. Precise concurrent audio programming has been an unsolved (and ill-defined) problem. ChucK provides a concurrent programming model that solves this problem and significantly enhances designing, developing, and reasoning about programs with complex audio timing. ChucK employs a novel data-driven timing mechanism and a related time-based synchronization model, both implemented in a virtual machine. We show how these features enable precise, concurrent audio programming and provide a high degree of programmability in writing real-time audio and multimedia programs. As an extension, programmers can use this model to write code on-the-fly -- while the program is running. These features provide a powerful programming tool for building and experimenting with complex audio synthesis and multimedia programs.

Abstract: Aspect oriented programming (AOP) is a new programming paradigm that offers a novel modularization unit for the crosscutting concerns. Functionalities originally spread across several modules and tangled with each other can be factored out into a single, separate unit, called an aspect. The source code fragments introduced to port an existing application to a distributed environment (such as Java RAH) are typically scattered and tangled, thus representing an ideal candidate for the usage of aspects. In This work, we propose a distribution framework based on AOP and we describe the steps necessary to migrate an existing program to it. In our solution, the original application remains oblivious of the distribution concern and all required aspects are generated automatically. The approach was validated on a case study.

Abstract: Java provides a clean object-oriented programming model and allows for inherently system-independent programs. Unfortunately, Java has a limited concurrency model, providing only threads and remote method invocation (RMI).The JR programming language extends Java to provide a rich concurrency model, based on that of SR. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, asynchronous communication, rendezvous, and dynamic process creation. JR's concurrency model stems from the addition of operations (a generalization of procedures) and JR supports the redefinition of operations through inheritance. JR programs are written in an extended Java and then translated into standard Java programs. The JR run-time support system is also written in standard Java.This paper describes the JR programming language and its implementation. Some initial measurements of the performance of the implementation are also included.

Abstract: Pair programming provides many benefits, both to the programmers and to the product that they develop. However, pair programming is limited to those situations in which the developers can collocate, preventing its benefits from being enjoyed by the widest possible audience. A software tool that allowed the pair to work from separate locations would address this limitation. This paper presents some initial results from a distributed pair programming experiment in which students in an introductory programming class used such a tool. Student perceptions of distributed pair programming are also discussed.

Abstract: This paper presents Fair Threads, a new model for concurrent programming. This multi-threading model combines preemptive and cooperative scheduling. User threads execute according to a cooperative strategy. Service threads execute according to a preemptive strategy. User threads may ask services from service threads in order to improve performance by exploiting hardware parallelism and in order to execute non-blocking operations.Fair threads are experimented within the context of the functional programming language Scheme. This paper also presents the integration in this language. That is, it presents a semantics for Scheme augmented with Fair Threads and the main characteristics of the implementation.

Abstract: Summary form only given. The Java programming language supports concurrency. Concurrent programs are harder to verify than their sequential counterparts due to their inherent nondeterminism and a number of specific concurrency problems such as interference and deadlock. In previous work, we proposed a method for verifying concurrent Java components based on a mix of code inspection, static analysis tools, and the ConAn testing tool. The method was derived from an analysis of concurrency failures in Java components, but was not applied in practice. In this paper, we explore the method by applying it to an implementation of the well-known readers-writers problem and a number of mutants of that implementation. We only apply it to a single, well-known example, and so we do not attempt to draw any general conclusions about the applicability or effectiveness of the method. However, the exploration does point out several strengths and weaknesses in the method, which enable us to fine-tune the method before we carry out a more formal evaluation on other, more realistic components.

Abstract: A thread is a basic unit of program execution that can share a single address space with other threads - that is, they can read and write the same variables and data structures. Originally, only assembly programmers used threads. A few older programming languages such as PL/I supported thread concurrency, but newer languages such as C and C++ use libraries instead. Only recently have programming languages again begun to build in direct support for threads. Java and Ada are examples of industry-strength languages for multithreading. The Java thread model has its roots in traditional concurrent programming. As the "real-time specification for Java" sidebar describes, RTSJ attempts to remove some of the limitations relative to real-time applications - primarily by circumventing garbage collection. But RTSJ does not make the language safer. It retains standard Java's threading pitfalls and is a risky candidate for critical concurrent applications.

Abstract: The term inheritance anomaly was coined in 1993 by Matsuoka and Yonezawa [15] to refer to the problems arising by the coexistence of inheritance and concurrency in concurrent object oriented languages (COOLs). The quirks arising by such combination have been observed since the early eighties, when the first experimental COOLs were designed [3]. In the nineties COOLs turned from research topic to widely used tools in the everyday programming practice, see e.g. the Java [9] experience. This expository paper extends the survey presented in [15] to account for new and widely used COOLs, most notably Java and C# [19]. Specifically, we illustrate some innovative approaches to COOL design relying on the aspect oriented programming paradigm [13] that aim at better, more powerful abstraction for concurrent OOP, and provide means to fight the inheritance anomaly.

Abstract: Figure 0. Some things associated with an Audicle. Abstract Many software environments have been developed for computer music. Programming environments typically provide constructs to implement synthesis or musical algorithms, whereas runtime environments allow performers to exert parametric control over their programs onstage, in real-time. We present a new type of audio programming environment that integrates the programmability of the development environment with elements of the runtime environment. The result, called the Audicle, is a novel integration of a concurrent "smart" editor, compiler, virtual machine, and debugger, all running in the same address space, sharing data, and working together at runtime. We believe this augmentation has the potential to fundamentally enhance the way we write and visualize audio programs both offline and on-the-fly. In this paper, we examine existing programming and runtime environments, present the ideas behind the Audicle, and demonstrate its features and properties. Our model of the Audicle is integrated with the ChucK programming language and inherits many of its fundamental properties, including: decoupling of data-flow and time, concurrency, and modularity for on-the-fly programming. We discuss the main components of the Audicle, and show that it not only provides a useful class of programming tools for real-time composition and performances, but also motivates a new type of on-the-fly programming aesthetic - one of visualizing the audio programming process.

Abstract: In the development of any technology, there's always a tendency to lose sight of the basic problems that stimulated its introduction in the first place. Technologies in software construction are no exception. One of the essential parts of software construction is the underlying programming paradigm. In the last few decades, different software construction paradigms have evolved - for example, structured programming in the 1970s and object-oriented programming in the 1980s. Although OOP dominates current software construction, it introduces several problems that might raise questions about its understandability and efficiency. W. Cave (1995) was the first to propose and develop the separation principle as a programming paradigm. One major contribution is that it moves most complex issues related to data sharing, parameter passing, and scope into a programming model in which simple graphics can represent access to data. The separation principle can simplify or even eliminate these issues. By expressing access permissions in simple, canonical drawings, the separation principle makes it easy to comprehend the full range of relationships between data and instructions, and thus the code's structure. A simple way to show connectivity, a key property affecting program understandability, is by separating data from instructions. Two of prediction systems' flagship products, the visual software environment (VSE) and the general simulation system (GSS), embody this idea. This paper discusses the separation principle in the context of conventional languages such as C and C++.

Abstract: In previous work, JavaSymphony has been introduced as a high level programming model for performance-oriented distributed and parallel Java programs. We have extended JavaSymphony to simplify the development of Grid applications written in Java, allowing the programmer to control parallelism, load balancing, and locality at a high level of abstraction. In this paper, we introduce new features to support the widely popular workflow paradigm. The overall idea is to provide a high level programming paradigm that shields the programmer from low level implementation details such as RMI, sockets, and threads. Experiments will be shown to demonstrate the usefulness of JavaSymphony as a programming paradigm for the Grid.

Abstract: Real-time (RT) applications are designed to control systems that are inherently parallel. For easing development, abstractions are mandatory to model this concurrency. To achieve this goal, the real-time object paradigm is proposed. It is used to demonstrate how to separate functional and concurrency concerns ensuring also high-level abstraction for parallelism modeling

Abstract: Teaching the need and methods of producing secure and reliable code is one of the challenges of teaching programming in an academic setting. Some programming languages like Ada are designed to protect programs from common program deficiencies. Other languages like Java are more trusting and rely on the programmer to bullet-proof his/her own code. This article discusses issues that should be addressed through programming style and coding guidelines. Students applying these guidelines produce more reliable programs and learn good programming practices. Programming standards are not a novel concept but one that bears revisiting in light of languages like Java.

Abstract: Within an environment of parallel objects, an approach of structured parallel programming and the object-orientated paradigm, shows a programming method based on high level parallel compositions or HLPCs (CPANs in Spanish) by means of classes. The synchronous and asynchronous communication ways and the asynchronous future of the pattern of parallel objects, the predefined patterns of communication/interaction of the structured approach, the encapsulation and the abstraction of the object-orientated approach, to provide reusability to these patterns, together with a set of predefined restrictions of synchronization among processes (maxpar, mutex, sync) are used. The implementation of the commonly used communication patterns is explained by means of the application of the method, which form a library of susceptible classes for use in applications within the programming environments of C++ and of the standard POSIX of programming with threads.

Abstract: Thing-oriented programming (TP) is centered around the concept of a “Thing”. A thing in an executing software system is bound to behave like an object does in our real world. TP is an emerging programming model which overcomes some of the limitations of current practice in software development in general and of object-oriented programming (OOP) in particular. Ercatons provide an implementation of the model. TP does not describe a new programming language. The so-called “ercato virtual machine” or “ercato engine” implements the ideas discussed and has been used to validate the concepts described here.

Abstract: Programming contests have a long established role as co-curricular activities. But as programming methodology has changed, the programming contest problems have not reflected these changes. In this paper, we describe a way to modernize the traditional ACM-style contest while preserving the problem solving aspects. We do so by introducing a new type of problem that requires that solutions interact with pre-defined classes. We discuss the effects of this change on a contest conducted for high school students.

Abstract: Exception handling is a very popular technique for incorporating fault tolerance into software systems. However, its use for structuring concurrent, distributed systems is hindered by the fact that the exception handling models of many mainstream object-oriented programming languages are sequential. In this paper we present an aspect-based framework for incorporating concurrent exception handling in Java programs. The framework has been implemented in AspectJ, a general purpose aspect-oriented extension to Java. Our main contribution is to show that AspectJ is useful for implementing the concerns related to concurrent exception handling and to provide a useful tool to developers of distributed, concurrent fault-tolerant applications.

Abstract: In this article a new concurrent object-oriented programming language is presented. This language ‐ named MP-Eiffel (Multi-Processor Eiffel) ‐ is developed as an extension to the sequential object-oriented language Eiffel. This choice is not accidental. Eiffel’s powerful, safe, and simple object-oriented semantics proved to be an excellent framework to introduce concurrency mechanisms. The choices made for the language concurrent mechanisms, and their semantics, resulted from an attempt to provide a safe and simple integration of the essential properties of both worlds: concurrent and sequential object-oriented programming. In section 2 the essential characteristics, requirements, problems, and elementary solutions of concurrent programming are briefly reviewed. Object-oriented sequential programming is then briefly introduced, giving emphasis to its fundamental and useful properties. Since this work is about creating programming language mechanisms, some important language design rules are enumerated and succinctly justified. Those rules will be used to justify the choices made in MP-Eiffel. Several existing possibilities for integrating concurrency in an object-oriented language are presented and evaluated in section 4. A special care is taken to study the conditions under which unsafe interference may arise from the joint use of some mechanisms, such as the well known problem of “inheritance anomalies”. It is shown that such problems can be prevented without compromising neither of the essential properties of both worlds.

Abstract: Information and knowledge are actually well and easily distributed thanks to electronic journals, news, mailing-lists and forums. It is however more difficult to deploy algorithmic and programming collaboration: the heterogeneity of the programming languages and the operating systems used by researchers constitutes a major problem to the design of a common testing platform. Current solutions exist to develop collaborative work. Generally, these solutions impose specific programming languages and/or operating systems to developers. Some others specific rules have to be respected. These heavy constrains slow down the usage of collaborative programming platforms. The OpenWatermark project proposes a modern architecture for cooperative programming exchanges that takes all these aspects into account. Developers work with their favorite programming languages and operating systems as long as the OpenWatermark platform supports them. In this paper, we present the OpenWatermark platform (www.openwatermark.org) and its application to the benchmarking of image watermarking algorithms.

Abstract: Programming efficient and reliable code can be considered a non-trivial task, as it requires deep understanding of the problem to be solved along with good programming skills. However, software frameworks and programming paradigms can provide a dependable infrastructure upon which better programs can be written and deployed. This allows engineers to focus mainly on their task, while relying on the underlying run-time environment for taking care of low-level programming issues, such as memory allocation and disposal, typing consistency and interface compliance. In this paper, we argue that strong-typed programming languages and paradigms offer a valid support for the production of reliable programs. Aware of the challenges of formal measurement metrics for code quality, we present the benefits of strong-typing by considering a practical application: the design and implementation of RoboX, a tour-guide robot for the Swiss National Exhibition Expo.02. The example is extremely well suited for such a discussion, since complex mechatronic applications can be considered critical systems - i.e., systems whose failure may endanger missions, lives and society - thus their reliability has to be made a prime concern.

Abstract: The invention relates to novel cyclododecane derivatives of the general formula (I) wherein R1 and R2 represent independently from each other a hydrogen atom, a C1-6 alkyl group or a C3-8 cycloalkyl group, or R1 and R2 form together with the nitrogen atom to which they are attached a heterocyclic ring containing 4 to 7 carbon atoms and optionally a further heteroatom selected from the group consisting of oxygen, sulphur and nitrogen, said ring may be optionally substituted by a C1-3 alkyl or benzyl group; and A represents a C2-6 straight or branched alkylene chain, and optically active isomers, acid addition salts and quaternary ammonium derivatives thereof. The invention relates further to an analogous process for the preparation of said compounds, to pharmaceutical compositions containing said compounds as the active ingredient and to a process for the preparation of said pharmaceutical compositions. The cyclododecane derivatives of the invention possess valuable biological properties.

Abstract: Low-level language constructs used for expressing explicit communication, concurrency, synchronization, and parallelism in distributed systems for parallel processing are considered harmful. We are providing a programming model to support implicit communication, concurrency, synchronization, and parallelism in systems through an implicit coordination-oriented approach. A 4-layered interconnection architecture will be implemented to facilitate programming in an integrated manner. The implicit coordination-oriented approach to supporting parallel programming provides a number of benefits. Without inserting the low-level language constructs in an unstructured manner in programs makes the programs modular. Modularity improves the maintainability of the programs. Our approach supports the portability of programs by allowing the programs in different programming languages to be executed in any general programming environment without modifications.

Abstract: Intensional programming is a declarative programming paradigm that involves the programming of expressions placed in an inherently multidimensional context space. It is an emerging and evolving domain of very general application. The general intensional programming system (GIPSY) aims at the development of a programming system that would allow very dynamic investigations on the possibilities of intensional programming and all its widely different flavors and domains of application. Requirement as a key driver to any systems or software effort, it provides the basis for all of the following development work by R. R. Young (2001). Capture effective requirements is human activity works on a system design. This work focuses on the requirements capturing for the GIPSY system, the method to achieve the requirements, and considering each effective requirements practices in the context of our current work.

Abstract: Modern Platform FPGAs contain a combination of processors, embedded memory, programmable interconnect, dedicated DSP elements, and conventional lookup tables. On top of that they have multiple clock domains, very high speed Serial I/Os and a large number of pins.This talk will focus on the programming of these systems. Conventional general purpose processors have been successfully programmed with sequential, control dominated programming languages like C and C++. This programming style has been succesfull for high-end DSPs, only after the architecture of the DSPs were tuned. This tuning required the interaction between compiler writers and processor architects.Todays conventional FPGAs are programmed with VHDL or Verilog. The semantics of these languages enable significant current systems at the expense of relatively low-level, explicit timing oriented programming.The existing notion of Dataflow models should be very good for expressing concurrency in high-end DSP systems. One of the first programming environments for FPGAs that exploit this is the Matlab/Simulink environment.This talk will show how the various dataflow models can be exploited to build more powerfull programming environments for todays FPGAs. In particular the combination of programming models and the systematic design of architecture elements is extremely powerfull. The talk will finish by showing the interesting research directions that can have a significant impact on the design of future FPGA platforms. The various approaches will be illustrated with facts and figures from actual designs, including JPEG2000 and MPEG4 encoders and decoders.