Integrating visual aids into an object oriented programming environment

An object-oriented programming (OOP) environment for developing SEMI Equipment Communication Standard (SECS) applications with the C++ and C programming languages in a Unix workstation environment is described. The system defines a set of programming objects corresponding to the standard SECS-II item types, messages and headers as well as a number of support classes and operations. Conversion between standard program datatypes and SECS-II items is transparent or explicitly managed by the developer. Within a standard framework using standard C++ input/output methods, SECS-II messages may be created, analyzed, transmitted and received between internal buffers, external files and communication channels. Classes corresponding to specific SECS stream and function codes are also available and can be incorporated easily into application code with little or no modification.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Describes an architecture for implementing Electronic Meeting Systems (EMS) applications in an Object-Oriented Programming Environment. The environment is based on the C++ programming language and personal computers communicating over a local area network. An overview of C++ class concepts and terminology is included to familiarize the reader with terminology peculiar to C++ and necessary for the implementation of the design. The Object-Oriented EMS architecture is a three tier structure having layers for base classes, tools, and applications. The OO-EMS design addresses concurrency control, object addressing, duplicated objects, and broadcast communications. >

This paper describes how hypertext concepts are supported in an object-oriented programming environment. Program fragments and documentation fragments are modelled as objects in an object-oriented programming language and several kinds of links are provided between these objects. Therefore the term hyperobject system is used. The links support document organizational relationships, abstract presentation, annotations, program semantical relationships, and program-documentation relationships.

The work concerns the selection of the programming language and environment for the needs of neural modeling of the power and electricity demand generation system in terms of uninhabited factories. Therefore, the main goal of the conducted research is to obtain the best possible Artificial Neural Network, i.e. to teach it a model of a real system, which is a system for generating demand for power and electricity based on numerical data on parts of the power system operation in terms of uninhabited factories. The learning capabilities of artificial neural networks were checked by comparing the MSE error and the Regression Index R2. In each of the examined programming languages and related programming environments, i.e. Matlab, Python and Wolfram, an Artificial Neural Network with the same structure and properties was designed and implemented, i.e. with the same number of input and output neurons, the number of hidden layers and the number of neurons in them, the activation function of neurons and the learning method. In addition to the ANN training of the system model, testing and validation as well as comparative studies were carried out.

A versatile virtual transducer response curve-tracer based on PC-based data-acquisition system is presented. The measuring scheme was developed using a fourth generation graphical programming language (Test-point) and a high performance data acquisition card. The chosen framework is centered on a concurrent, time sensitive, object-oriented (OO) programming environment, which in general is suited to the construction of real time applications. The graphical programming methods allow a high degree of software modularity and provide the features needed for data acquisition, analysis, testing, simulation and modeling. The implemented functions are described and the use of the system is examined by means of some practical measurement examples. The experimental setup described in this paper can be used to obtain the response characteristics for different types of transducers and sensors. The added feature of the proposed system is its suitability for on-line as well as off-line operations to obtain the experimental data for curve-fitting based on the principle of least mean squares (LMS).

FoCaLiZe is an object-oriented programming environment that combines specifications, programs and proofs in the same language. This paper describes how its features can be used to formally express specifications and to develop by stepwise refinement the design and implementation of secured systems, while proving that the implementation meets its specification or design requirements. We thus obtain a modular implementation of a generic framework for the definition of security policies together with certified enforcement mechanism for these policies.

Evaluations of JaguarCode: A web-based object-oriented programming environment with static and dynamic visualization

In the context of heterogeneous networks, like clusters of workstations, the design of programming and execution environments aims both to easily express parallelism and distribution of applications, at conception level, and to adapt automatically their execution to fluctuations that may appear in the evolution of applications or in resources availabilities. We present the ADAJ environment (adaptive distributed applications in Java), targeted towards Java applications, which addresses these aims, through conceptual tools offered by the programming environment and through a dynamic load balancing mechanism, integrated at the middleware level. At a conception level, the developer has the possibility of easily activating processing in a MIMD programming model, using library calls. At the execution level, the efficiency of execution in ADAJ exploits an observation mechanism, which allows to acquire information on processing behaviour in order to dynamically redistribute load, by object migrations.

When we began, some years ago, building a programming environment for the logical programming language Prolog, the goals we had in mind were predominantly technical ones. Our basic aim was to combine the logical and object-oriented programming styles and to compile a set of tools for constructing Prolog software in a uniform environment. Once we felt we had found satisfactory solutions to the problems involved, we released the programming environment for use by other development groups. We were astounded to find that the external use of our environment led to a number of unexpected problems. We then began not only to eliminate technical errors and inconsistencies, but also to reflect on how it was possible for these problems to arise. The conclusion we reached was that we needed to find answers to a number of questions which went well beyond the original technical problems: What are the building blocks of a programming environment and how can they be “invented”? What is a good building block and how can it be smoothly integrated into an environment? How does an operational building block become an integral part of the developer’s daily work? What are we doing when we develop a programming environment and what are we doing when we work with it?

This paper describes the design and the implementation of OOPE, the graphical programming environment of the prototype version of O2, an object-oriented database system. One of the distinguishing features of this environment is that it mixes the functionalities of programming environments, of both databases and programming languages. Thus, it facilitates and fastens not only the schema design, but also the development of application programs. Another interesting characteristic is that it is being developed using as much as possible the functionalities provided by the O2 system, namely the programming language, the database and the graphics functionalities.

In the 1960s, Papert introduced Logo language that commanded a graphic turtle. These were the first advances in the field of educational robotics. Many environments were created in this theme; however, most programming environments are highly graphical, so they do not provide accessible interfaces for visually impaired users. Thus, our research presents challenges and recommendations in terms of usability and accessibility in designing a robot programming environment for people who are visually impaired. We conjectured that by using a programming language to guide a robot in a virtual environment, the person who is visually impaired could better understand orientation and mobility skills. Hence, we created the GoDonnie programming language based on the Logo language. GoDonnie runs in a programming environment called Donnie. We show all the design process of Donnie, that was based on interactive design. Participates in this study, people who are visually impaired and sighted programming professors. Results indicate that GoDonnie and Donnie have good usability, supports the development of orientation and mobility in visually impaired people, and meets the expectations regarding the programming environment. Finally, we created a set of design guidelines for developing robot programming environments for people who are visually impaired.

Prograph is a programming environment and language which has been available on the Apple Macintosh platform for more than 5 years. It provides a sophisticated application builder, together with a visual programming language, supported by a powerful program development environment. The programming language uses an object-oriented model for data abstraction and the logic is based on a dataflow model of computation, specified graphically.Graphical dataflow gives programmers a clear view of the potential for exploitation of concurrency and so the Prograph language appears to give some leverage for the programming of parallel or distributed systems. This still leaves many issues unresolved, however, since for example dataflow is usually associated with fine-grain parallelism, but expected target architectures are unlikely to support fine-grain parallelism efficiently. This paper discusses the preliminary investigation of the issues of Prograph and parallelism.KeywordsParallel EvaluationApple MacintoshDataflow GraphDataflow ModelRemote ExecutionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

It is well known that students face many difficulties when they have to learn programming. Generally, these difficulties arise from two main reasons: i) the kind of exercises proposed by the teacher, and ii) the programming language used for solving those problems. The first problem is overcome by selecting an interesting application domain for the students. The second problem is tackled by using programming languages specialized for teaching. Nowadays, there are many programming languages aimed at simplifying the learning process. However, many of them still have the same drawbacks of traditional programming languages: the language used to write the statements is different from the programmers' native language; and the syntactic rules impose many tricky restrictions not easy to follow. This paper presents an approach for solving the problems previously mentioned. The approach consists of using: an application domain motivating for the student, the Project Hoshimi (PH); and a programming environment, PH-Helper that is a simple and user-friendly syntax-directed editor and compiler for Hoshimi Language (HL), the actual PH programming language.

MathWorks provides a platform-independent execution engine that runs MATLAB code, a single desktop environment to develop the code and an extensive library of well-documented functions to assist one in solving programming problems. In deciding to work with MATLAB, the user is choosing a tightly bundled package of tools, optimized and improved over decades. However, other programming languages and software can offer additional functionality and power. This chapter discusses the integration of software written in other programming languages and environments. Examples are shown for system commands, the Java and Python programming languages and the .NET framework.

Data sets in large applications are often too massive to fit completely inside the computers internal memory. The resulting input/output communication (or I/O) between fast internal memory and slower external memory (such as disks) can be a major performance bottleneck. In this article we survey the state of the art in the design and analysis of external memory (or EM) algorithms and data structures, where the goal is to exploit locality in order to reduce the I/O costs. We consider a variety of EM paradigms for solving batched and online problems efficiently in external memory. For the batched problem of sorting and related problems such as permuting and fast Fourier transform, the key paradigms include distribution and merging. The paradigm of disk striping offers an elegant way to use multiple disks in parallel. For sorting, however, disk striping can be nonoptimal with respect to I/O, so to gain further improvements we discuss distribution and merging techniques for using the disks independently. We also consider useful techniques for batched EM problems involving matrices (such as matrix multiplication and transposition), geometric data (such as finding intersections and constructing convex hulls), and graphs (such as list ranking, connected components, topological sorting, and shortest paths). In the online domain, canonical EM applications include dictionary lookup and range searching. The two important classes of indexed data structures are based upon extendible hashing and B-trees. The paradigms of filtering and bootstrapping provide a convenient means in online data structures to make effective use of the data accessed from disk. We also reexamine some of the above EM problems in slightly different settings, such as when the data items are moving, when the data items are variable-length (e.g., text strings), or when the allocated amount of internal memory can change dynamically. Programming tools and environments are available for simplifying the EM programming task. During the course of the survey, we report on some experiments in the domain of spatial databases using the TPIE system (transparent parallel I/O programming environment). The newly developed EM algorithms and data structures that incorporate the paradigms we discuss are significantly faster than methods currently used in practice.