Visual Zero: A persistent and interactive object-oriented programming environment

In this article, an ongoing research project held in the Computer Science department of the University of Vigo is described. Its main objective is to develop an interactive object-oriented environment, serving as a vehicle for learning object-oriented programming. It currently consists of a virtual machine, an assembler, compilers for two high-level programming languages, and an educational visual programming environment. Its main characteristics are (a) the support of prototype-based object orientation, which is a model of object orientation that actually wraps the class-based model; (b) the support for object persistence, which simplifies all input/output issues to the minimum, and (c) the availability of a new visual programming environment is an invaluable help. We the authors think that the combination of all of these possibilities, will lead to an interesting, useful tool that would be recommended for object-oriented teaching. The whole system has been successfully employed in a number of different courses, allowing students to concentrate on objects and their relationships from the very beginning, and thus helping them to achieve a high degree of knowledge about the object-oriented programming paradigm.     

PEP: An interactive programming system with an Algol-like programming language

PEP (Program Editor and Processor) is an interactive programming system based on an Algol-like language. It is intended to replace BASIC as a system for interactive program development on small computers (LSI-11). The language processed by the system allows declaration of variables, constants and procedures; it has structured statements for conditional and repetitive execution of program parts. We describe design and implementation of the system and give our impressions after 1 year of experience with the system.     

An implementation of the object-oriented concurrent programming language SINA

SINA is an object-oriented language for distributed and concurrent programming. The primary focus of this paper is on the object-oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter-object communication, some illustrative examples and a message-based implementation model for SINA that we have used in our current implementation.     

A comparison of object-oriented programming in four modern languages

Object-oriented programming has become a widely used, important programming paradigm that is supported in many different languages. C++ has become the most widely used object-oriented language and many C++ programmers are unfamiliar with the different approaches taken by other languages in the paradigm. This paper is intended as an introduction to a broad range of ideas in object-oriented programming. Specifically, we introduce four modern programming languages that support object-oriented programming (Oberon-2, Modula-3, Sather and Self), and show how a simple application is coded in these languages. While each of these programming languages provide support for inheritance, dynamic dispatch, code reuse, and information hiding, they do so in very different ways and with varying levels of efficiency and simplicity. The use of a simple example, based on a common programming problem, facilitates our comparison. We have coded the application in all of these languages, including C++, and we compare the compile times, object code sizes, and run times of the available implementations. Implementations of all the languages compared and all of the programs we measure are available on the Internet. Ultimately, our goal is to encourage and facilitate programmers in understanding and exploring a variety of object-oriented programming languages.     

TGMS: An object-oriented system for programming geometry

TGMS (tiered geometric modelling system) is an experimental system intended to reduce the difficulty and cost of developing new solid modelling applications while preserving investment in an existing, time-tested, solid modeller. The application developer writes programs in the TGMS language, which consists of a base language augmented by data types (classes) for geometry. The base programming language is AML/X, an object-oriented language intended for use in design and manufacturing applications. Solid modelling is done using an interface to GDP (geometric design processor), an existing, production-quality solid modelling system. TGMS shows how a system written in a non-object-oriented language can be used as a base for an object-oriented application programming environment. This paper presents the design of TGMS and discusses important aspects of its implementation. The TGMS language defines classes and methods that provide an interface to functions and data represented in a non-object-oriented language. To implement TGMS, issues related to communication, storage management and consistency were addressed. These, and other, implementation issues are discussed. The paper includes sample programs and a summary of feedback from TGMS users. It concludes that the use of object-oriented programming for geometry has many benefits, and that an object-oriented system can be built on top of a non-object-oriented system at less cost than building the equivalent object-oriented system from scratch.     

Files in an interactive environment

A well designed file system can significantly simplify the design of and increase the reliability of interactive programs. A summary of the specifications of a convenient file system that is substantially independent of the host operating system and some experiences using the system are described.     

Constructing an integrated visual programming environment

This paper presents an object-oriented architecture, called the Model-View-Shape (MVS) architecture, for constructing an Integrated Visual Programming Environment (IVPE), whose constituent tools deal with (fine-grained) language semantics, as well as a mass of graphics-drawing activities. This architecture enforces a layered and loosely-coupled structure, so that the user-interface part of components may be more independent, maintainable, and reusable than those proposed in the original model-view-controller architecture. An MVS class hierarchy, systematically constructed using C++, can be reused and extended with new semantics to rapidly develop new tools for an existing IVPE, or even an IVPE supporting more than one language. The present editors developed can be used to construct programs by specifying the associated flow information in explicit (visual) or implicit (textual) ways, while the (incremental) flow analysers can help analyse incomplete program fragments to locate and inform the user of possible errors or anomalies during programming. © 1998 John Wiley & Sons, Ltd.     

Localized tensor-based solvers for interactive finite element applications using C++ and Java

This paper presents techniques for solving systems of equations arising in finite element applications using a localized, tensor-based approach. The approach is localized in that a major part of the solution responsibility is delegated to vector degree-of-freedom objects, rather than residing solely in a global solver working on a monolithic data structure. The approach is tensor-based in that the fundamental quantities used for computation are considered to be second-order tensors. The localized data structure strategy provides the benefits of an efficient sparse and symmetric storage scheme without requiring complex implementation code. The tensor-based aspect of the approach can bring substantial performance benefits by increasing the granularity at which solution algorithms deal with their data. Java and C++ implementations of interactive finite element programs are used to demonstrate performance that is competitive with other available solvers, especially in the case of problems for which interactive analysis is feasible on commonly available hardware.     

The design of an interactive program development system for Pascal

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program-structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.     

R: a data analysis and statistical programming environment–an emerging tool for the geosciences

A statistical computation, programming and graphics language is available at no cost under the GNU Public Licence. This programming environment is available in source code and binary code forms and is supported for a number of operating systems. The R language is similar to the S language and is a package that allows users to apply methods of data analysis, statistics and graphical rendering of results in an interactive windows-based environment. The R language is supported by a large development and user's group. Additional data analysis and statistical libraries have been contributed by many users and can be obtained from the Comprehensive R Archive Network (CRAN).     

RELOOP, an algebra based query language for an object-oriented database system

In most object-oriented databases, as opposed to value-oriented databases, data are accessed by a programming language instead of a declarative query language. End users do not have a simple tool to perform their queries. This paper is concerned with the definition of an SQL-like query language on top of the O₂ object-oriented database system. We study the influence of the object-oriented paradigm on a query language, describe our language through examples, define its semantics by means of an algebra and sketch the compilation of RELOOP in one of the languages supported by the O₂ system.     

An interactive fuzzy programming approach for bi-objective straight and U-shaped assembly line balancing problem

The consideration of this paper is given to address the straight and U-shaped assembly line balancing problem. Although many attempts in the literature have been made to develop deterministic version of the assembly line model, the attention is not considerably given to those in uncertain environment. In this paper, a novel bi-objective fuzzy mixed-integer linear programming model (BOFMILP) is developed so that triangular fuzzy numbers (TFNs) are employed in order to represent uncertainty and vagueness associated with the task processing times in the real production systems. In this proposed model, two conflicting objectives (minimizing the number of stations as well as cycle time) are considered simultaneously with respect to set of constraints. For this purpose, an appropriate strategy in which new two-phase interactive fuzzy programming approach is proposed as a solution method to find an efficient compromise solution. Finally, validity of the proposed model as well as its solution approach are evaluated though numerical examples. In addition, a comparison study is conducted over some test problems in order to assess the performance of the proposed solution approach. The results demonstrate that our proposed interactive fuzzy approach not only can be applied in ALBPs but also is capable to handle any practical MOLP models. Moreover, in light of these results, the proposed model may constitute a framework aiming to assist the decision maker (DM) to deal with uncertainty in assembly line problem.     

Eventor: an authoring system for interactive multimedia applications

Programming, testing, and maintaining interactive multimedia applications (IMAs) are still difficult and expensive, while substantial progress has been made to reduce the burden on authors. As IMAs get larger and more complex the difficulties will increase. To overcome the complexity of such IMAs, we argue that authoring systems should provide such facilities as (1) a traditional and intuitivedivide-and-conquer paradigm for solving large and complex problems in various fields, (2)formal specification of the behaviors of IMAs for checking the syntactic correctness of visual expressions or semantic anomalies, and (3)automatic aids like validation of temporal constraints and verification of visual expressions. In this paper, we investigate the properties of IMAs for recognizing the inherent interactivity and concurrency. We propose a specification method based on Milner'sCalculus of Communicating Systems (CCS), which is a well-known formal mechanism for specifying the concurrency in various distributed applications. We also design and implement an authoring system calledEventor (Event Editor), which is based on CCS and composed of three tools: a Temporal Synchronizer, a Spatial Synchronizer, and a User Interaction Builder. They focus on describing the temporal and spatial synchronizations and user interactions while they rely on existing tools in Intel's Digital Video Interactive (DVI) for supporting other functionalities. By editing a simple computer aided instruction (CAI) application, we illustrate that our specification mechanism is well-suited for handling the interactivity of multimedia applications, and Eventor is a simple, efficient, and powerful enough tool to handle practical applications. Especially the incremental refinement and the formal specification based on the CCS allow Eventor to be extended with formal verifications to cope with large and complex applications.     

Using interactive multiobjective methods to solve DEA problems with value judgements

Data envelopment analysis (DEA) is a performance measurement tool that was initially developed without consideration of the decision maker (DM)'s preference structures. Ever since, there has been a wide literature incorporating DEA with value judgements such as the goal and target setting models. However, most of these models require prior judgements on target or weight setting. This paper will establish an equivalence model between DEA and multiple objective linear programming (MOLP) and show how a DEA problem can be solved interactively without any prior judgements by transforming it into an MOLP formulation. Various interactive multiobjective models would be used to solve DEA problems with the aid of PROMOIN, an interactive multiobjective programming software tool. The DM can then search along the efficient frontier to locate the most preferred solution where resource allocation and target levels based on the DM's value judgements can be set. An application on the efficiency analysis of retail banks in the UK is examined. Comparisons of the results among the interactive MOLP methods are investigated and recommendations on which method may best fit the data set and the DM's preferences will be made.     

Leave and recall: Primitives for procedural programming

Two primitives for structured programming are introduced. The primitives allow a generalized procedure entry and return similar to the ‘loop’ and ‘break’ statements found in many algorithmic languages for control in repetitive commands. Examples are given and the practicality of the primitives especially for interactive programming is stressed. Finally, the detailed implementation of the primitives is discussed; they may be implemented as procedures within an existing language.     

Specification and verification challenges for sequential object-oriented programs

The state of knowledge in how to specify sequential programs in object-oriented languages such as Java and C# and the state of the art in automated verification tools for such programs have made measurable progress in the last several years. This paper describes several remaining challenges and approaches to their solution.     

Robot programming using augmented reality: An interactive method for planning collision-free paths

Current robot programming approaches lack the intuitiveness required for quick and simple applications. As new robotic applications are being identified, there is a greater need to be able to programme robots safely and quickly. This paper discusses the use of an augmented reality (AR) environment for facilitating intuitive robot programming, and presents a novel methodology for planning collision-free paths for an n-d.o.f. (degree-of-freedom) manipulator in a 3D AR environment. The methodology is interactive because the human is involved in defining the free space or collision-free volume (CFV), and selecting the start and goal configurations. The methodology uses a heuristic beam search algorithm to generate the paths. A number of possible scenarios are discussed.