Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models

The upcoming many-core architectures require software developers to exploit concurrency to utilize available computational power. Today's high-level language virtual machines (VMs), which are a cornerstone of software development, do not provide sufficient abstraction for concurrency concepts. We analyze concrete and abstract concurrency models and identify the challenges they impose for VMs. To provide sufficient concurrency support in VMs, we propose to integrate concurrency operations into VM instruction sets. Since there will always be VMs optimized for special purposes, our goal is to develop a methodology to design instruction sets with concurrency support. Therefore, we also propose a list of trade-offs that have to be investigated to advise the design of such instruction sets. As a first experiment, we implemented one instruction set extension for shared memory and one for non-shared memory concurrency. From our experimental results, we derived a list of requirements for a full-grown experimental environment for further research

An overview of very high level software design methods

Very High Level design methods emphasize automatic transfer of requirements to formal design specifications, and/or may concentrate on automatic transformation of formal design specifications that include some semantic information of the system into machine executable form. Very high level design methods range from general domain independent methods to approaches implementable for specific applications or domains. Applying AI techniques, abstract programming methods, domain heuristics, software engineering tools, library-based programming and other methods different approaches for higher level software design are being developed. Though one finds that a given approach does not always fall exactly in any specific class, this paper provides a classification for very high level design methods including examples for each class. These methods are analyzed and compared based on their basic approaches, strengths and feasibility for future expansion toward automatic development of software systems

Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

THREAD: A programming environment for interactive planning-level robotics applications

THREAD programming language, which was developed to meet the needs of researchers in developing robotics applications that perform such tasks as grasp, trajectory design, sensor data analysis, and interfacing with external subsystems in order to perform servo-level control of manipulators and real time sensing is discussed. The philosophy behind THREAD, the issues which entered into its design, and the features of the language are discussed from the viewpoint of researchers who want to develop algorithms in a simulation environment, and from those who want to implement physical robotics systems. The detailed functions of the many complex robotics algorithms and tools which are part of the language are not explained, but an overall impression of their capability is given

ooRexx 5 Yielding Swiss Army Knife Usability

The new version 5.0 of the message based object-oriented programming language ooRexx ("open object-oriented REXX") is easy to learn, yet powerful. This article introduces some of the new language features with nutshell examples that at the same time demonstrate its power when deployed in different operating system environments. The modern native API of ooRexx makes it in addition very easy to extend the language with new functionality and deploy it as a macro language for any C++-based application

From Smalltalk to Silicon: Towards a methodology to turn Smalltalk code into FPGA

International audienceDue to their ability to combine high performances along with flexibility, FPGAs (Field Programmable Gate Array) are used in robotic applications nowadays, especially in case of realtime applications. The FPGA circuits are often designed and configured using the Hardware Description Languages (HDLs) like VHDL or Verilog. However, although these languages provide abstractions up to the functionality level, they lack many features of todays modern languages that make them unsuited for high-level models and systems. In this paper, we present an overview of a methodology that uses a Dynamic Reflective Language, such as Smalltalk, for high level hardware/software co-design on FPGAs

Graphical Programming of Simulation Models in an Object-Oriented Environment

Graphical programming has been used in conjunction with conventional simulation languages via block diagrams or activity networks. Its beneficial effects on programming and modeling in simulation have been accepted by everyone involved in these languages. However, none of these conventional techniques is truely interactive. Given the level of the current hardware and software technology, it is possible to design a very good graphical programming system which supports an interactive incremental programming style in specifications of simulation models. The benefit of such a visual system would go beyond the modeling phase of a simulation study and it might as well be realized in understanding the behavior of complex problems, in being a communication and training medium for the user and developers, and finally in presenting the simulation results. In this study, the graphical programming methodology has been investigated from the perspective of object-oriented simulation. The truely interactive and graphical orientation of some of the object-oriented languages (e.g., Smalltalk-80) has opened up new avenues of research in this very important topic. Today, the nature of this type of research will be not whether it can be done but how the known techniques should be combined to yield the highest benefit

A Programming Environment Evaluation Methodology for Object-Oriented Systems

The object-oriented design strategy as both a problem decomposition and system development paradigm has made impressive inroads into the various areas of the computing sciences. Substantial development productivity improvements have been demonstrated in areas ranging from artificial intelligence to user interface design. However, there has been very little progress in the formal characterization of these productivity improvements and in the identification of the underlying cognitive mechanisms. The development and validation of models and metrics of this sort require large amounts of systematically-gathered structural and productivity data. There has, however, been a notable lack of systematically-gathered information on these development environments. A large part of this problem is attributable to the lack of a systematic programming environment evaluation methodology that is appropriate to the evaluation of object-oriented systems