Nautilus, a Concurrent Diagrammatic Specification and Programming Language

Nautilus is a high-level specification and programming language having abstraction mechanisms not commonly found in other programming languages inspired by its semantic domain (a categorial model named Nonsequential Automata). It constitutes an elegant solution for concurrency and non-determinism as well as for synchronization of concurrent systems. The role as specification language highlights the diagrammatic syntax (it was originally text based).The diagrammatic syntax for Nautilus allows complete programs to be written using symbols and graphical diagrams. The graphical notation was elaborated in order to be able to express all the structures in the language, yet trying to improve the visualization of written programs. A brief comparison with UML is included. To support Nautilus as a programming language, a mapping to Java is constructed, setting the basis for an execution environment of Nautilus specifications.     

Real time animation of dynamic processes

Animation and simulation processes are facilitated by the use of high level graphic languages. The results of these processes are not generally available in real time, developing of microfilm delaying the screening of the process until some time after the computer run.A technique is described which overcomes this problem whilst still allowing the use of a high level graphical language.The addition of a single feature to a ‘static’ graphical language has transformed it into a ‘dynamic’ graphical language allowing real time illustration of time varying processes.The technique is not restricted to the language described but may well be employed by other high level graphical languages.     

EPS: An ‘elementary’ programming system for the Delft Parallel Processor

A programming system for synchronous parallel processors, like the DPP-84 working in synchronous mode, is proposed. In EPS a program consists of a collection of well-defined and separate units, described in a conventional procedure-oriented language like PASCAL or MODULA-2. The connection between the ‘elementary’ program units is laid in a supervisory ‘configuration’ program, which defines both the spatial and time relations between the units. The concept of ‘virtual’ parallel processing is introduced, which enables the construction of logical parallel programs, independent of the number of processing elements actually available.     

The KRAKATOA tool for certificationof JAVA/JAVACARD programs annotated in JML

We describe the basic structure of an environment for proving programs annotated with JML specifications. Our method is generic with respect to the API, and thus well suited for applets certification. It involves three distinct components: the tool, which computes proof obligations for a core imperative language annotated with pre- and post-conditions, the proof assistant for modeling the program semantics and conducting the development of proofs, and finally the tool, a translator of our own, which reads the files and produces specifications for and a representation of the semantics of the program into ’s input language.     

Leogo: An Equal Opportunity User Interface for Programming

Leogo is a novel programming environment supporting an ‘equal opportunity’ user interface which allows users to express their programming tasks through any mixture of three concurrently active programming paradigms: by direct-manipulation using ‘programming by demonstration’, by clicking buttons and dragging sliders in an iconic language and by typing commands in a normal text-based language. Equal opportunity ensures that the effects of any interface action are simultaneously displayed across each of the three paradigms—input expressions in one paradigm cause output of equivalent expressions in the other two paradigms. Leogo is designed to promote programming skills in primary and junior schools, but the interface properties it demonstrates are applicable to a wide range of novel programming environments. Leogo's motivation, design, development and preliminary usability study are described.     

Justifying reliability claims for a fault-detecting parallel architecture

This paper describes ‘Goal Structuring Notation’ (GSN), a graphical notation that can be used to structure and present an argument justifying some aspect of system performance. The design of a fault-detecting processor pair is examined to determine the extent to which it is indeed ‘fault-detecting’. It is argued that for complex systems, difficulties with assessment arise not so much from a lack of analysis techniques, but from the need to integrate the results from many diverse analyses into a coherent and compelling argument. It is suggested that GSN provides a framework in which such an argument can be made.     

时序逻辑语言XYZ/E中指针的形式化表示与验证

指针是一种重要的数据类型,使用指针能使程序更加有效和优美.可是指针却以不易驾御而闻名,至今在时序逻辑语言中未见到对它的形式化工作.XYZ/E既是一个时序逻辑系统也是一个程序设计语言,它能表示普通高级语言中几乎所有的重要机制.本文主要讨论在时序逻辑语言XYZ/E中指针的形式化表示问题以及在结构化XYZ/SE程序中指针的验证问题.     

An empirical study on the efficiency of different design pattern representations in UML class diagrams

Design patterns are recognized in the software engineering community as useful solutions to recurring design problems that improve the quality of programs. They are more and more used by developers in the design and implementation of their programs. Therefore, the visualization of the design patterns used in a program could be useful to efficiently understand how it works. Currently, a common representation to visualize design patterns is the UML collaboration notation. Previous work noticed some limitations in the UML representation and proposed new representations to tackle these limitations. However, none of these pieces of work conducted empirical studies to compare their new representations with the UML representation. We designed and conducted an empirical study to collect data on the performance of developers on basic tasks related to design pattern comprehension (i.e., identifying composition, role, participation) to evaluate the impact of three visual representations and to compare them with the UML one. We used eye-trackers to measure the developers’ effort during the execution of the study. Collected data and their analyses show that stereotype-enhanced UML diagrams are more efficient for identifying composition and role than the UML collaboration notation. The UML representation and the pattern-enhanced class diagrams are more efficient for locating the classes participating in a design pattern (i.e., identifying participation).     

Towards a Programming Language for Interaction Nets

Interaction nets were introduced almost 15 years ago. Since then they have been put forward as both a graphical programming paradigm and as an intermediate language into which we can compile other languages. Whichever way we use interaction nets, a problem remains in that the language is very primitive. Drawing an analogy with functional programming, we have the λ-calculus but we are missing the functional programming language: syntactic sugar, language constructs, data-structures, etc. The purpose of this paper is to make a first step towards defining such a programming language for interaction nets.     

Specification Diagrams for Actor Systems

Specification diagrams (SD's) are a novel form of graphical notation for specifying open distributed object systems. The design goal is to define notation for specifying message-passing behavior that is expressive, intuitively understandable, and that has formal semantic underpinnings. The notation generalizes informal notations such as UML's Sequence Diagrams and broadens their applicability to later in the design cycle. Specification diagrams differ from existing actor and process algebra presentations in that they are not executable per se; instead, like logics, they are inherently more biased toward specification. In this paper we rigorously define the language syntax and semantics and give examples that show the expressiveness of the language, how properties of specifications may be asserted diagrammatically, and how it is possible to reason rigorously and modularly about specification diagrams.     

网络实时系统的一种活动性描述语言*

介绍了ADL,它是一种基于网络实时系统的活动性描述语言,一种描述并发处理中时态和功能行为的新的形式规格说明符号.ADL专用于计算机网络,是DORIS的一种形式语言扩充.它组合了状态机活动(ASM)的图形符号和基于模型的活动功能行为(AFB)符号;提供了关于ASM的抽象语法和静态、动态语义.最后通过一个小实例说明该语言是如何解释指定网络实时系统的.     

Logic programming for process planning in the domain of sheet metal forming with progressive dies

In this work an intelligent system pertaining to sheet metal part and process design has been developed, storing knowledge and prescribing ways to use this knowledge according to the ‘programming in logic’ paradigm. The sheet metal parts covered by the software are those having U shape and being manufactured by bending (folding), cutting and piercing with particular emphasis on progressive dies. The use envisaged and corresponding parts of the system are: checking the part design for manufacturability, planning process phases, and checking the configuration of press tools involved. Particular attention is paid to the presentation of knowledge that has been gathered from handbooks and verified / enhanced in industry. This is first presented in natural language and then its formal representation in Prolog is described and explained by examples. Part design and press tool checking knowledge is relatively straightforward to represent and structure ‘linearly’. Process planning knowledge is based on patterns that are captured in lists and activated in a case-by-case fashion exploiting the power of Prolog. Validation of the system was conducted using examples from industry.     

Yacc in sasl — an exercise in functional programming

Among the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.     

PMS—A program to make learning Pascal easier

One of the essential tasks in the teaching of a programming language is the introduction of the main constructs of the language—the syntax and semantics of statements, control, procedures, file handling, and so on. Most teachers present this topic by simulating the operation of the computer on the chalkboard by manual tracing of the execution of sample demonstration programs. Upon closer inspection it becomes clear that this task could be performed by the computer itself. A program implementing this idea would help the teacher in the class and the student (who could use the computer to repeat the instructor's performance at any time and on any problem of his choice) both in the class and in study. This article describes a collection of programs called PMS that performs exactly this function for the teaching of Pascal.PMS is organized as a collection of “mimlanguages” each of which demonstrates, and allows the user to experiment with, a certain category of Pascal features using a particular screen representation. Each of the subsystems contains a syntax-driven, screen-oriented translator associated with an interpreter that controls execution and the appropriate screen representation. This modular structure of PMS reflects the fact that programming is always taught by presenting certain essentially disjoint language features individually. In addition to their logical independence, these disjoint concepts also require different graphical approaches for their visual representation and this reinforces the need for modularization of the package.PMS is written in Pascal and runs on several computers including the IBM PC.     

Interactive programs in a functional language: A functional implementation of an editor

The transition from imperative programming to functional programming for problems whose mathematical nature is not immediately obvious raises two questions. First, how can the function concept be applied to such problems, and, secondly, what language concepts are most suited in this situation. This paper shows that an existing functional programming language is very well suited for the elegant implementation of interactive programs. As an example, a text editor is described. The implementation of the editor has once more demonstrated the benefits of functional programming: fast generation of short and reliable programs. This indicates that it is worth while to investigate the application fields of functional programming languages as well as their implementation, in order to try to make them into general-purpose programming languages that can be used in a production environment.     

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.     

On the specification and implementation of distributed systems using NMDS and LIPS

This paper describes a graphical notation called NMDS and an implementation language called LIPS for producing distributed systems. NMDS is a set of notations based on Role Activity Diagrams with features for expressing concurrency, dataflow and communication and it lends itself to elicitation and verification while expressing concurrency unambiguously in a concise manner. It also fits in with the syntax and semantics of LIPS. LIPS is a distributed message passing language that promotes the separation of communication from computation by using the concept of guarded processes. One of the major advantages of using NMDS with LIPS is that reverse engineering of LIPS programs can easily be achieved.     

The object-oriented functional data language

The object-oriented functional data language (O²FDL) is an interactive strongly typed database programming language that integrates the object-oriented and functional programming paradigms. It was designed for advanced applications that require a powerful and uniform database programming language supporting the software engineering principles of these tow paradigms. To this end, the O² FDL supports inheritance and encapsulation of object-oriented languages, and an equational notation and strong typing of functional programming. Strong typing is extended with type restrictions to constrain the instantiations of type variables in function interfaces, while inheritance is augmented with a monotonic subtype rule for function redefinition. The O²FDL also supports novel features. For the core of the O²FDL, a denotational semantics based on an extended λ-calculus is provided. For selected system-defined functions, operational semantics are provided and it is demonstrated that a subset of the O²FDL is at least as expressive as the relational algebra