A Graph-Rewriting Visual Language for Database Programming

Textual database programming languages are computationally complete, but have the disadvantage of giving the user a non-intuitive view of the database information that is being manipulated. The visual languages developed in recent years have allowed naive users access to a direct representation of data, often in a graph form, but have concentrated on user interface rather than complex programming tasks. There is a need for a system which combines the advantages of both these programming methods.We describe an implementation of Spider, an experimental visual database programming language aimed at programmers. It uses a graph-rewriting paradigm as a basis for a fully visual, computationally complete language. The graphs it rewrites represent the schema and instances of a database.The unique graph-rewriting method used by Spider has syntactic and semantic simplicity. Its form of algorithmic expression allows complex computation to be easily represented in short programs. Furthermore, Spider has greater power than normally provided in textual systems, and we show that queries on the schema and associative queries can be performed easily and without requiring any additions to the language.     

Robot language for manipulation systems programming,teaching, and verification of control algorithms

The paper describes language UMS for manipulation task programming and manipulation systems teaching. Basic features of the language are outlined and the approach to the trajectory synthesis with motion statements is described. The structure of the language is briefly explained as well as the instruction set. The language is compared with some other industrial robot languages.     

Chicon—a Chinese text manipulation language

Text processing is an important computer application. Due to its importance, a number of text manipulation programming languages have been devised (e.g. Icon). These programming languages are very useful for applications such as natural language processing, text analysis, text editing, document formatting, text generation, etc. However, they were mainly designed to handle English texts, and are ineffective for Chinese. This is because English and Chinese texts are represented very differently in a computer. An English character is mainly represented in 7-bit ASCII, and its Chinese counterpart commonly in 16-bit GB or BIG-5. This difference makes direct application of English-based text manipulation programming languages to Chinese erroneous, e.g. application of Icon to reverse a string of Chinese characters. In this paper, a new dialect of Icon, referred to as Chicon (i.e. Chinese Icon), is proposed. In the design of Chicon, new data types were introduced to differentiate pure English and English/Chinese mixed texts. In addition, existing Icon text manipulation functions were modified to account for Chinese texts. Experiments have shown that Chicon not only could overcome the problems of Chinese processing in Icon, but its execution speed was actually superior to Icon in handling Chinese. Furthermore, application of Chicon to a real sized problem, namely word segmentation, has proved that the language is practical. © 1998 John Wiley & Sons, Ltd.     

Visual Programming in a Visual Shell—A Unified Approach

Pursuit is a desktop interface designed to enable non-programmers to construct programs that automate routine repetitive tasks in a way that is consistent with the direct manipulation paradigm. Pursuit combines a Programming by Demonstration (PBD) interface with an editable, visual program representation language. The representation language differs from existing visual languages because it explicitly represents data objects and implicitly represents operations by changes to the data objects. In addition, the language provides concise ways to handle and represent error conditions and dialog boxes.     

From metaphors to microworlds. The challenge of creating educational software

Every time we use a computer we are working with metaphors. In some cases the metaphor is obvious, and in others not. This aspect of the computer is what makes it so useful. User interface metaphors like desktops, menus and windows can make computing appear more like the “real” activities in which we take part. In the realm of educational software, the task of programming boils down to the creation of a metaphorical microworld in which the user can interact with tasks and simulations that are designed to aid the acquisition and development of knowledge.Programming is hard no matter which language is used. The reasons why traditional authoring languages such as PILOT have failed to sweep through educational computing have nothing to do with the syntax or structure of programming languages but more to do with the failure of the underlying metaphor. The major difference between various high level languages are not to be found in their syntaxes, grammars, or vocabularies, but in their metaphors. A Pascal programmer sees a program as a collection of procedures, a Smalltalk programmer as objects and messages. The trick to making programming easy is to make the metaphor of the language match that of the application.Construction set languages including good spreadsheet programs have become immensely popular tools arising from their ease of use as a direct consequence of the consistency of the metaphor as one moves from programming to execution. Construction sets have a strong limitation; they are not general-purpose tools. The closest we have come to general purpose direct manipulation languages is with products like Filevision (a Macintosh-based visual database) and Guide.Paper-based media are very well suited to linear progression from one topic to another. As soon as it becomes important to branch between two activities, they become cumbersome to use. It is the ability of computer programs to branch which gives them quite different functions from documents. While programming languages allow the creation of branching programs, there is a new class of application programs which provide the same capability based on metaphors that are a natural evolution from the linear world of paper-based documents. Hypermedia is a term that refers to this class of software, not to one particular application; for example, Filevision is a hypermedia database tool. Hypermedia tools have great potential as authoring systems and they can make life much more exciting for those of us involved in educational computing.     

Should ML be Object-Oriented?

At a fundamental level, functional and object-oriented programming languages are all ‘higher-order’, in the sense that they support computing with values that are themselves pieces of program code encapsulated with a local environment. In functional languages these ‘active’ values are functions, while in object-oriented languages they are objects. Both styles of higher-order language claim to provide good support for writing adaptable programs, but functional and object-oriented languages achieve this adaptability in different ways: functional programs rely on parameterisation at the value, type and module level, while object-oriented languages rely primarily on subtyping and implementation inheritance. Here we compare these two approaches, mainly in terms of the features and properties of their type systems, and consider the benefits and disadvantages of unifying (or merging) the two paradigms by adding object-oriented features to ML as a base language. We argue that while some of the simpler aspects of object-oriented languages are compatible with ML, adding a full- edged class-based object system to ML leads to an excessively complex type system and relatively little expressive gain, especially if we aim to preserve that mostly functional style of programming that is a major advantage of ML. Received March 2002 / Accepted in revised form April 2002     

Agentsheets: a medium for creating domain-oriented visual languages

Customized visual representations enable end users to achieve their programming goals. Here, designers work with users to tailor visual programming languages to specific problem domains. We describe a design methodology and a tool for creating domain oriented, end user programming languages that effectively use visualization. We first describe a collaborative design methodology involving end users and designers. We then present Agentsheets, a tool for creating domain oriented visual programming languages, and illustrate how it supports collaborative design by examining experiences from a real language design project. Finally, we summarize the contributions of our approach and discuss its viability in industrial design projects     

Visual programming with analogical representations: Inspirations from a semiotic analysis of comics

Analogical representations based on pictures of domain objects can be used in visual programming to provide a close mapping between the program and the resulting runtime display, which can make programming easier for children and other users. The use of graphical rewrite rules with before and after pictures is an example of this approach. Graphical rewrite rules have some similarities with comics strips, which also use picture sequences of graphical objects to describe dynamics in a static form. However, the visual language of comics is not used to its full potential in visual programming. We discuss how a semiotic analysis of comics can be used to address some of the limitations of graphical rewrite rules. We use a visual programming system we have designed to illustrate that comic strips can express more general computations and be more intuitive and flexible than traditional graphical rewrites. Our conclusion is that the visual language of comics has a strong potential for increasing the expressiveness and flexibility of visual programming with analogical representations of domain objects, while maintaining a direct mapping between the program representation and the runtime representation.     

Implementation of visual languages using pattern‐based specifications

The implementation of visual languages requires a wide range of conceptual and technical knowledge from issues of user interface design and graphical implementation to aspects of analysis and transformation for languages in general. We present a powerful toolset that incorporates such knowledge. Our toolset generates editors from high‐level specifications. A language is specified by identifying certain patterns in the language structure and selecting a visual representation from a set of precoined solutions. Visual programs are represented by attributed abstract trees. Therefore, further phases of processing visual programs can be generated by state‐of‐the‐art tools for language implementation. We demonstrate that even challenging visual languages can be implemented with reasonably little effort and with rather limited technical knowledge. The approach is suitable for a large variety of visual language styles. Copyright © 2003 John Wiley & Sons, Ltd.     

程序变换在程序语言中的一种表示——兼论变换型语言

本文首先引入了“变换型语言”的概念,给出了代表这种语言特征的机制:“变换模块”和“变换控制命令”的具体定义;举例说明了如何使用“变换模块”描述一个抽象数据类型的部分实现,并通过“变换控制命令”来完成程序中抽象变量及有关操作的变换过程;最后,讨论了变换型语言表示的抽象性,一般性和控制的灵活性,以及变换型程序的正确性等问题。     

Design of a Mobile Robot Controller using Esterel Tools

Robot controllers are often programmed using either standard sequential programming languages or a robot-specific language, which are then compiled to assembly language specific to the robot. Modern real-time programming languages, on the other hand, are more appropriate to program robots, as they better fit the real-time reactive model of robots. This paper reports on a project to program a non-trivial robot, the Rug Warrior, in the Artificial Intelligence Laboratory of UNSW, using Esterel, which is a real-time programming language. The approach is illustrated by simulation of a colony of Siberian ants using a group of Rug Warriors.     

Programmable applications: exploring the potential for language/interface symbiosis

Programmable applications are software systems that seek to combine the learnability and accessibility of direct manipulation interfaces with the expressive power and range of programming languages. In this paper we explore techniques for creatively integrating language and interface constructs within programmable applications. Using SchemePaint—a programmable graphics application—as a source of examples, we demonstrate how an interface and language can combine symbolically and thereby provide powerful modes of expression within applications.     

Learning second and subsequent programming languages: A problem of transfer

Learning second and subsequent programming languages is easier than learning a first programming language because many concepts and constructs are shared. However, it is still a hard task. In this protocol analysis of moderately experienced programmers transferring to a new programming language, we classified episodes by whether they involved the syntactic, semantic, or planning level of programming knowledge. We discovered that most episodes involve planning and that in solving a given subproblem there are typically many cycles of language‐independent tactical planning followed by language‐dependent implementation planning. On the other hand, programmers have relatively minor problems with the syntax and semantics of a new language. Our subjects’ protocols and their final programs revealed that the plans they develop are strongly influenced by their knowledge of what would be convenient and appropriate in other languages they know. This prevents them from taking full advantage of the capabilities of the new language.     

Artificial intelligence and robotic assembly

Traditionally, most industrial robots are programmed by teaching. The emergence of robot-level programming languages has improved the programmer's ability to describe and modify the robot moves. However, commercially available robot-level programming languages still fall short of the robot user's need to program complex tasks, and consequently, are not widely used in industry. There is an increasing need for integrating sensors feedback into the robot system to provide better perception and for improving the capacity of the robot to reason and make decisions intelligently in real time.The role of artificial intelligence in programming and controlling robots is discussed. Available robot programming systems including robot-level, object-level, and task-level languages are reviewed. The importance of developing intelligent robots in broadening the scope of flexible automation and opening the door to new robotic applications in space, under water and in harsh environments is outlined. The current development and implementation of programming and control systems for intelligent robots, at McMaster University, are explained. A number of research issues are discussed such as (1) automatic task planning, (2) knowledge representation and use, (3) world modeling, (4) reasoning in automatic assembly planning, and (5) vision monitoring of actions. Examples of geometric, functional, and handling reasoning, as they apply to assembly, are provided. The systems described in this paper are being implemented in the center for flexible manufacturing research and development. Several pieces of hardware are used, including a six-axis articulated robot, a grey-level vision system with a multi-camera, Micro VAX II, and a variety of graphics monitors. The languages available for software development include Common LISP, C, OPS5, VAL II, PASCAL, and FORTRAN 77. The domain of application is currently focused on mechanical assembly.     

Scaling up visual programming languages

The directness, immediacy, and simplicity of visual programming languages are appealing. The question is, can VPLs be effectively applied to large scale programming problems while retaining these characteristics. In scaling up, the problem is how to expand applicability without sacrificing the goals of better logic expression and understanding. From a size standpoint, scaling up refers to the programmer's ability to apply VPLs in larger programs. Such programs range from those requiring several days' work by a single programmer to programs requiring months of work, large programming teams, and large data structures. From a problem domain standpoint, scaling up refers to suitability for many kinds of problems. These range from visual application domains-such as user interface design or scientific visualization-to general purpose programming in such diverse areas as financial planning, simulations, and real time applications with explicit timing requirements. To illustrate the scaling up problem, we discuss nine major subproblems and describe emerging solutions from existing VPL systems. First, we examine representation issues, including static representation, screen real estate, and documentation. Next, we examine programming language issues-procedural abstraction, interactive visual data abstraction, type checking, persistence, and efficiency. Finally, we look at issues beyond the coding process     

A STEP-compliant Industrial Robot Data Model for robot off-line programming systems

Recently, various robot off-line programming systems have promoted their own robot data models, resulting in a plethora of robot representation methods and unchangeable data files among CAx and robot off-line programming systems. The current paper represents a STEP-compliant Industrial Robot Data Model (IRDM) for data exchange between CAx systems and robot off-line programming systems. Using this novel representation method, most resources involved in a robot manufacturing system can be represented. The geometric and mathematic aspects of industrial robots have been defined in IRDM, so that the robot off-line programming system could have abundant information to represent robots’ kinematic and dynamic behaviors. In order to validate the proposed models and approaches, a prototype robot off-line programming system with 3D virtual environment is presented. The functionalities of IRDM not only have significant meaning for providing a unified data platform for robot simulation systems, but also have the potential capability to represent robot language using the object-oriented concept.     

COCOVILA – Compiler-Compiler for Visual Languages

A compiler-compiler for visual languages is presented. It has been designed as a framework for building visual programming environments that translate schemas into textual representation as well as into programs representing the deep meaning of schemas. The deep semantics is implemented by applying attribute grammars to schema languages; attribute dependencies are implemented as methods of Java classes. Unlike compiler-compilers of textual languages, a large part of the framework is needed for support of interactive usage of a visual language.     

Programmable applications: exploring the potential for language/interface symbiosis

Abstract

Programmable applications are software systems that seek to combine the learnability and accessibility of direct manipulation interfaces with the expressive power and range of programming languages. In this paper we explore techniques for creatively integrating language and interface constructs within programmable applications. Using SchemePaint—a programmable graphics application—as a source of examples, we demonstrate how an interface and language can combine symbolically and thereby provide powerful modes of expression within applications.     

Ontology oriented programming in go!

In this paper we introduce the knowledge representation features of a new multi-paradigm programming language called go! that cleanly integrates logic, functional, object oriented and imperative programming styles. Borrowing from L&O [1] go! allows knowledge to be represented as a set of labeled theories incrementally constructed using multiple-inheritance. The theory label is a constructor for instances of the class. The instances are go!’s objects. A go! theory structure can be used to characterize any knowledge domain. In particular, it can be used to describe classes of things, such as people, students, etc., their subclass relationships and characteristics of their key properties. That is, it can be used to represent an ontology. For each ontology class we give a type definition—we declare what properties, with what value type, instances of the class have—and we give a labeled theory that defines these properties. Subclass relationships are reflected using both type and theory inheritance rules. Following [2], we shall call this ontology oriented programming. This paper describes the go! language and its use for ontology oriented programming, comparing its expressiveness with Owl, particularly Owl Lite[3]. The paper assumes some familiarity with ontology specification using Owl like languages and with logic and object oriented programming.     

A visual representation of cellular automata-like systems

Cellular automata (CA) models and corresponding algorithms have a rich theoretical basis, and have also been used in a great variety of applications. A number of programming languages and systems have been developed to support the implementation of the CA models. However, these languages focus on computational and performance issues, and do not pay enough attention to programming productivity, usability, understandability, and other aspects of software engineering.In this paper, we describe a new special-purpose programming language developed for visual specification, presentation, and explanation of CA systems within a visual programming environment, as well as, for programming them. This language is based on using visual patterns, colors, and animation for representing the CA system structures and operations on these structures, and for performing editing and composing manipulations with corresponding software components. Examples of the CA algorithm representations and some details of the environment implementation are presented.