Predicates and pixels

This paper explores the possibilities of programming with graphical representations of logic programs. Two example programs are given in the concurrent logic language FGDC but many languages based on rewrite rules would be suitable for the same treatment. A graphical syntax promises to make programming in suitable ultra high level languages easier and more intuitive.     

Exploring the Effect of Control-Flow and Traversal Direction on VPL Usability for Novices

Programming is a hard cognitive activity, especially for novices who also have to struggle with learning the intricacies of the programming language syntax. We postulate that a well-designed diagrammatic visual programming language (VPL) to replace or substitute a textual programming language may help in the learning programming process. Our research focuses on the suitability of diagrammatic notations for such a VPL. In this paper, we report results from two experimental studies into diagrammatic notations. The first experiment shows the superiority of three visual representations over a conventional style textual program in both control- and data-flow paradigms. The result also shows the effect of programming paradigm on novices' performance. The second experiment focuses on two aspects of program flow representation: the graphical representation to be used for sequencing, and the traversal direction required of diagram users. It reveals that graphical representation does not affect performance in tracing program flow but that traversal direction makes a difference in cognitive demand on users. The evidence also indicates a control-flow preference among novices.     

Automatic generation of visual programming environments

We have developed the visual language compiler-compiler (VLCC) system to automatically generate visual programming environments. VLCC is a grammar based system that can support implementation of any visual language by assisting the language designer in defining the language's graphical objects, syntax, and semantics. The final result of the generation process includes an integrated environment with a visual editor and a compiler for the defined visual language. In VLCC, graphical tools define visual languages to create both graphical objects and composition rules. Visual editors enable language designers to directly and visually manipulate the syntax of these languages. To capture the widest range of visual languages, the VLCC system can be configured for a specific language class. Different language classes can be characterized depending on their graphical objects' structure and on the way they can be composed. Also, box and arrow diagrams are defined for primitive objects with attaching points and for composition rules to join boxes and arrows at those attaching points. After choosing the visual language type to create, the designer can concentrate on language definition details. VLCC uses the positional grammar model as its underlying grammar formalism     

A Classification Framework to Support the Design of Visual Languages

An important step in the design of visual languages is the specification of the graphical objects and the composition rules for constructing feasible visual sentences. The presence of different typologies of visual languages, each with specific graphical and structural characteristics, yields the need to have models and tools that unify the design steps for different types of visual languages. To this aim, in this paper we present a formal framework of visual language classes. Each class characterizes a family of visual languages based upon the nature of their graphical objects and composition rules. The framework has been embedded in the Visual Language Compiler–Compiler (VLCC), a graphical system for the automatic generation of visual programming environments.     

Unix tools as visual programming components in a GUI‐builder environment

Development environments based on ActiveX controls and JavaBeans are marketed as ‘visual programming’ platforms; in practice their visual dimension is limited to the design and implementation of an application's graphical user interface (GUI). The availability of sophisticated GUI development environments and visual component development frameworks is now providing viable platforms for implementing visual programming within general‐purpose platforms, i.e. for the specification of non‐GUI program functionality using visual representations. We describe how specially designed reflective components can be used in an industry‐standard visual programming environment to graphically specify sophisticated data transformation pipelines that interact with GUI elements. The components are based on Unix‐style filters repackaged as ActiveX controls. Their visual layout on the development environment canvas is used to specify the connection topology of the resultant pipeline. The process of converting filter‐style programs into visual controls is automated using a domain‐specific language. We demonstrate the approach through the design and the visual implementation of a GUI‐based spell‐checker. Copyright © 2001 John Wiley & Sons, Ltd.     

Rule inferencing and object-orientation for boundary elements mesh design

In this paper, object orientation and rule inferencing are used to automate the design of boundary element meshes. The work is part of an effort to develop an object-oriented integrated environment for the damage tolerance design of aircraft stiffened panels and other parts such as fuselage lap-joints. An inference domain class library has been developed. Inference domain objects are used to create symbolic representations for the structural configuration and for production rules that describe the mesh design strategy. An objectoriented inference engine is utilized to apply this rule set to the knowledge base where the symbolic representation of the structural configuration is stored. The technique was implemented using the C++ programming language.     

A Methodology And Tool Set For Supporting The Development Of Graphical User Interfaces

A methodology and tool set for building application (assumed to be inherently non-graphical) software with graphical user interface is described. Initially, pure application software is built from a set of basic building blocks; subsequently, graphical representations for application objects are defined without direct coding and then the graphical user interface is generated automatically. This paper concentrates on the graphical representation aspects of the user interface. Portability, configurability and sound software engineering principles are major considerations in the design of the overall system architecture. The prototype implementation is based on VDM (Vienna Development Method), Object-based Design, GKS (Graphical Kernel System) and the programming language ADA. An example from CIM (Computer Integrated Manufacturing) is used to illustrate the methodology presented here.     

A generalized scheme for mapping parallel algorithms

A generalized mapping strategy that uses a combination of graph theory, mathematical programming, and heuristics is proposed. The authors use the knowledge from the given algorithm and the architecture to guide the mapping. The approach begins with a graphical representation of the parallel algorithm (problem graph) and the parallel computer (host graph). Using these representations, the authors generate a new graphical representation (extended host graph) on which the problem graph is mapped. An accurate characterization of the communication overhead is used in the objective functions to evaluate the optimality of the mapping. An efficient mapping scheme is developed which uses two levels of optimization procedures. The objective functions include minimizing the communication overhead and minimizing the total execution time which includes both computation and communication times. The mapping scheme is tested by simulation and further confirmed by mapping a real world application onto actual distributed environments     

Building Interpreters with Rewriting Strategies

Programming language semantics based on pure rewrite rules suffers from the gap between the rewriting strategy implemented in rewriting engines and the intended evaluation strategy. This paper shows how programmable rewriting strategies can be used to implement interpreters for programming languages based on rewrite rules. The advantage of this approach is that reduction rules are first class entities that can be reused in different strategies, even in other kinds of program transformations such as optimizers. The approach is illustrated with several interpreters for the lambda calculus based on implicit and explicit (parallel) substitution, different strategies including normalization, eager evaluation, lazy evaluation, and lazy evaluation with updates. An extension with pattern matching and choice shows that such interpreters can easily be extended.     

An overview of the K semantic framework

K is an executable semantic framework in which programming languages, calculi, as well as type systems or formal analysis tools can be defined, making use of configurations, computations and rules. Configurations organize the system/program state in units called cells, which are labeled and can be nested. Computations carry “computational meaning” as special nested list structures sequentializing computational tasks, such as fragments of program; in particular, computations extend the original language or calculus syntax. K (rewrite) rules generalize conventional rewrite rules by making explicit which parts of the term they read, write, or do not care about. This distinction makes K a suitable framework for defining truly concurrent languages or calculi, even in the presence of sharing. Since computations can be handled like any other terms in a rewriting environment, that is, they can be matched, moved from one place to another in the original term, modified, or even deleted, K is particularly suitable for defining control-intensive language features such as abrupt termination, exceptions, or call/cc.This paper gives an overview of the K framework: what it is, how it can be used, and where it has been used so far. It also proposes and discusses the K definition of Challenge, a programming language that aims to challenge and expose the limitations of existing semantic frameworks.     

Concurrent programming in VISO

Concurrent programming is more difficult to use and understand than sequential programming. In order to simplify this type of programming a number of approaches have been developed such as visual programming. Visual Occam (VISO) is a visual programming language for concurrent programming. It has a graphical syntax based on the language Occam and its semantics is represented both in petri net and process calculus. This paper presents a modular visual approach to write concurrent programs using the VISO language. Concurrent programs in VISO are specified graphically at different levels of abstraction. This paper describes this modular visual approach by constructing two examples in VISO. The first example is a simple concurrent program and it is mainly used to show the details of constructing a concurrent program in VISO. The second example is a larger concurrent program with more levels of abstraction. Copyright © 2000 John Wiley & Sons, Ltd.     

Interactive design of 3D models with geometric constraints

In this paper, an interactive graphical approach for the design of parameterized part-hierarchies is presented. Primitive solids can be grouped into compound objects, and multiple instances of a compound object can be used in further designs. Geometric relations between primitives and instances are specified by geometric constraints between their local coordinate systems. The user can specify and edit a model by direct manipulation on a perspective or parallel projection with a mouse, whereas a procedural model representations is automatically generated via visual programming. The obtained twoview approach offers two concurrent interface styles to the end-user and enables the combination of an intuitive direct manipulation interface with the expressiveness of a procedural modeling language.     

Using independence to enable parallelism on multicore computers

A simple programming abstraction based on the notion of independence is introduced as a means for mapping the independence inherent in an algorithm explicitly into its programmed solution. This enables a compiler and runtime system to exploit the independence and achieve efficient parallelism of execution on multicore processors. The constructs needed to express mutual independence among statements are proposed and their implementation in iOberon, an extension of the Active Oberon programming language, is defined. The programming language extensions, runtime support, and performance measurements are described in detail. We believe that this concept of specifying local disjoint program fragments can be applied to other programming languages. Copyright © 2010 John Wiley & Sons, Ltd.     

Automated Synthesis of Numerical Programs for Simulation of Rigid Mechanical Systems in Physics-Based Animation

Physics-based animation programs are important in a variety of contexts, including science, engineering, education and entertainment among others. Manual construction of such programs is expensive, time-consuming and prone to error. We have developed a system for automatically synthesizing physics-based animation programs for a significant class of problems: constrained systems of rigid bodies, subject to driving and dissipative forces, under the control of an interactive user. Our system includes a graphical interface for specifying a physical scenario, including objects, geometry and coordinate systems, along with a symbolic interface for specifying dynamical variables, forces and constraints operating in the scenario. The entities defined in the graphical interface serve as the underlying vocabulary for specifications entered in the symbolic interface. Our system partitions the constraints and dynamical variables into classes and assigns each class to be implemented in a different component of a general simulation program scheme. It generates a numerical C⁺⁺ simulation program that drives a real-time animation of the specified scenario. Our system is implemented as a collection of rewrite rules in the Mathematica programming language. Our approach provides some of the benefits of formal deductive program synthesis, while keeping the computational costs of program synthesis more in line with conventional program generator technology. We have successfully tested our system on numerous examples.