HyperPascal(ID:5108/hyp005)

Paul Lyons, Massey University, New Zealand

Visual programming dialect based on Pascal, permitting "hyperprogramming", which tries to map the idea-spaces of the programmer through several views of the programming itself.

from the website
HyperPascal is a revolutionary new visual language. Its data manipulation capabilities are modelled on those in Pascal, but its syntax makes great use of current GUI capabilities. For example, the program uses several windows (algorithms, expressed as modified structure diagrams occupy one such window), and automatic updating of the views in different windows is provided. The programmer creates the diagrams using a purpose-built graphic editor; then the program is compiled from the information in the diagram.
and elsewhere:
(Pascal was chosen as the test-case for the hyperprogramming ideas for its simplicity, not for its modernity).


Related languages
Pascal (ISO) => HyperPascal   Extension of
References:
  • Paul Lyons, Craig Simmons, and Mark Apperley, "HyperPascal: A Visual Language to Model Idea Space" Proceedings of the 13th New Zealand Computer Society Conference, August 1993, 492-508 view details Abstract:   This paper was presented at the New Zealand Computer Society Conference in 1993. It is the original publication about HyperPascal, antedating even Craig Simmons' M.Sc.thesis.
        It describes the first version of the HyperPascal, and includes some concepts that are outmoded. In particular, the ideas about "portholes" have been superceded by the Active Templates concept. pdf Abstract: Programmers develop problem solutions in an abstract idea space, where they can easily visualise different views of the solution. However, conventional programs exist in sequential text space, where these different views often become inextricably tangled.
    We reject the text-based single-sequence structure - which many visual programming languages have heedlessly adopted - in favour of a hyperspatial environment where optimally-structured, disparate, models of a problem solution can be fashioned, where model integration is facilitated, and where hyperspatial navigation is intuitive.
    To explore the hyperspace, we invented HyperPascal, a general-purpose visual programming language with the capabilities of Pascal. The language exploits the power of interactive graphic interfaces, automatically generating syntactically correct programs, but constraining the programmer's actions minimally. Later developments
    will go beyond the procedural paradigm to explore the relationship between higher level system design paradigms (like OOD) and hyperspace.
  • Bhandarkar, S. M. and B.M. Edwards, HyperPascal -- An Architecture Independent Pascal Interface for Parallel Programming, Proc. IEEE Southeastern Regional Conference, Raleigh, NC, March 1995, pp. 78--84. view details
  • Bhandarkar, S. M. and B.M. Edwards, HyperPascal for Architecture Independent Parallel Programming, Proc. IEEE Intl. Phoenix Conf. Computers and Communications, Phoenix, AZ, March 1995, pp. 451--457. view details
  • Bhandarkar, S.M. and C.B. Giberson, HyperPascal: Implementation of a Pascal based Interface for Parallel Programming on the Intel iPSC/860 Hypercube, Proc. Intl. Conf. Parallel and Dist. Processing Tech. and Appl. (PDPTA`95), Athens, GA, November 1995, pp. 755--764. view details
  • Paul Lyons "Manipulating Dynamic Data Structures with Pictures" discussion paper at Massey view details Abstract: We present a set of concepts which, together, allow pictorial programming of dynamic data structure manipulations. The work proceeded from a desire to improve upon the "variable_name, up-arrow dot fieldname is assigned value" paradigm for manipulating pointer-based data structures. This paradigm is sufficient and compact, but it
    forces programmers to work at such a detailed level that they lose sight of the big picture. External link: Online copy
  • Paul Lyons, "Programming in Several Dimensions", Proc. SoftVis ?99, (ed. A Quigley), December 3-4, 1999, 31-39 view details Abstract: Writing a program to solve a problem is a process that can be divided into two phases: first, we invent a mental model of the solution; secondly, we map the mental model onto a physical representation. The mental model is multidimensional and syntax-free; in today?s textual programming languages, the physical representation is singledimensional and syntax-burdened. In fact, it hasn?t changed greatly since Algol 60. Mapping from one representation to the other has remained a painstaking and error-prone task, in spite of the ready availability of immensely faster computers, massive amounts of memory, high-resolution graphics displays, and powerful graphic input mechanisms.
    The Hyperprogramming paradigm exploits these capabilities. A  hyperprogramming language employs different visualisations for different program components - for example one visual syntax is suitable for visualising algorithms and another is suitable for visualising subroutine nesting. Each visualisation is designed for minimal overlap with the others, and where overlap is essential, hyperlinks between the views are automatically provided to allow easy navigation between them, and automatic updating of shared information.
    HyperPascal was developed as a vehicle for exploring this idea. In creating a program, a HyperPascal programmer edits information in three main visualisations:
  • the action window visualisation, which represents algorithms using a visual language based on structure
    diagrams;
  • the data structure templates visual component, which represents dynamic data structure algorithms using beforeand-
    after pictures
  • the scope window visualisation, which represents declarations as a nested visualisation analogous to conventional
    subroutine nesting
  • Paul Lyons, "Traversing HyperPascal?s semantic Tree" Informal paper at Massey view details Abstract: This document contains some suggestions about how the HyperPascal interpreter should,or could work. The basic model is that the interpreter is a recursive subroutine thattraverses a tree representation of the HyperPascal program. The nodes in the treecorrespond to the various elements of the program; actions (assignment and subroutineinvocation actions), control icons (choices and loops), subroutine headers, and so on. Ateach node in the tree, the interpreter determines the type of the node, and actsaccordingly. At choice nodes, for example, it evaluates Boolean expressions - these arestored in subtrees of the choice node - and, according to the result returned by theBoolean expresssion, either does or does not, evaluate another subtree, corresonding tothe ?then? clause. This tree is called the Semantic Tree, because it specifies the semanticmeaning of the program icons. Each subroutine in the HyperPascal program has its ownSemantic Tree, and all the Semantic Trees are linked into another, higher-level structurecalled the Scope Tree that has one node for each subroutine in the program, linked into atree representation of the program?s subroutine hierarchy. Before discussing the SemanticTree in which the interpreter spends most of its time, we begin with a description of theScope Tree