By Topic

Computer Languages, 1988. Proceedings., International Conference on

Date 9-13 Oct. 1988

Filter Results

Displaying Results 1 - 25 of 55
  • Proceedings 1988 International Conference on Computer Languages (IEEE Cat. No.88CH2647-6)

    Save to Project icon | Request Permissions | PDF file iconPDF (81 KB)  
    Freely Available from IEEE
  • An intentional language as the basis of a 3-D spreadsheet design

    Page(s): 2 - 9
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (556 KB)  

    Plane Lucid is an extension of the language Lucid, a language based on intentional logic. The language allows values of expressions in a program to vary in space as well as in time; it provides spatial and temporal operators to combine values from different contexts (or different points in space and time). As an application of Plane Lucid, an intentional 3-D spreadsheet has been designed in which Plane Lucid is the definition language of the spreadsheet. The spreadsheet is considered as a single entity (called the spreadsheet variable) which varies in spatial and temporal dimensions; values of cells in the spreadsheet are values of the spreadsheet variable at different spatial and temporal points.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Programming through pictorial transformations

    Page(s): 10 - 16
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (702 KB)  

    Research into visualization and animation of programs has typically been approached from the viewpoint of how to automate, at least partially, the instrumentation of programs already written in conventional textual languages. PT (pictorial transformations) takes the approach that if instead of beginning with an existing program, one begins by first describing visual data representations and then visually manipulating them to develop program algorithms, then their animation is almost a side-effect of the development process. This approach simplifies the development of animated programs. The authors motivate the use of PT by way of an example application.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Efficient retargetable compiler code generation

    Page(s): 25 - 30
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (428 KB)  

    A discussion is presented of the design and implementation of a retargetable code generation system, UNH-CODEGEN, specifically designed for the bottom-up tree pattern matching algorithms. The authors describe experiments in which the system has been used to build compilers. These experiments demonstrate that the system can be used to quickly generate a code generator that will run fast (roughly four times the speed of the Portable C Compiler's code generators), that will be space-efficient, and that will make best use of the underlying machine description.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A language for high-level programming of mathematical applications

    Page(s): 31 - 40
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (664 KB)  

    A language system called the Automated Programmer automates a great deal of routine effort for scientific, engineering, and mathematical application programming. Its notation is modeled after conventional textbook mathematical representation, so that mathematical expressions can be entered just as they appear in conventional solution specifications. It uses a flexible vocabulary and syntax that emulates technical English. This approach enhances self-documentation, diminishes programming error, and eases maintainability and verifiability. System design is highly user-oriented, making the system easy to learn and use. Programs are input using a two-dimensional screen editor. Lexical restrictions are minimal, keyword synonyms are available, and various common synonymous syntactic structures are acceptable. Powerful input and output facilities are provided.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • PNSOFT: a menu-driven software package for Petri-net modeling and analysis

    Page(s): 41 - 47
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (348 KB)  

    A discussion is presented of PNSOFT, a user-friendly, menu-driven software package for Petri-net modeling and analysis of real-time systems. It aids in the design, management and analysis of Petri-net models. PNSOFT runs in an automated programming environment that provides both a graphical and a matrix interface for the creation and modification of Petri-net models in different environments. The proposed software package is written in the C programming language and is efficient with respect to both time and space. It can easily be upgraded to perform a variety of other functions. The data structures created by PNSOFT's editing facilities can be used by other application programs. Various functions and programs used for analytical operations can be directly accessed by the user, using a menu-driven interface, at different levels.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The FX-87 Interpreter

    Page(s): 65 - 72
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (555 KB)  

    The first implementation of the programming language FX-87, a polymorphic typed functional language based on a system for static program analysis, is described. This polymorphic effect system integrates type checking and side-effect analysis into a single framework and allows the automatic detection of parallelizable expressions at compile-time. In FX-87, every expression has two static properties: a type and an effect. Type and effect polymorphism permits the behavior of first-class procedures to be statically modeled. The integration of type and effect analysis has resulted in the first system that is able (by accurate modeling of the side-effects of procedure values and masking of unobservable effects in the heap) to detect a compile-time, parallelizable constructs in both functional and imperative programs.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distributed programming with shared data

    Page(s): 82 - 91
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (872 KB)  

    Operating system primitives (e.g. problem-oriented shared memory, shared virtual memory, the Agora shared memory) and languages (e.g. Concurrent Prolog, Linda, Emerald) for programming distributed systems have been proposed that support the shared-variable paradigm without the presence of physical shared memory. The authors look at the reasons for this evolution, the resemblances and differences among these proposals, and the key issues in their design and implementation. Many implementations are based on replication of data. The authors take this idea one step further, and discuss how automatic replication (initiated by the run-time system) can be used as a basis for a model, called the shared data-object model, whose semantics are similar to the shared variable model. They also discuss the design of a language for distributed programming, Orca, which is based on the shared-data-object model.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Language specification by multi-axiom grammars

    Page(s): 110 - 118
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (710 KB)  

    Multiaxiom grammars and language, presented as generalizations of context-free grammars and languages, are defined and used as a mechanism for programming language specification and implementation. It is shown how to divide such a grammar into a sequence of subgrammars that generate inductively the language specified by the original grammar. Furthermore, it is shown how to use this sequence of subgrammars for inductive language recognition by a process of tokenizing. Two classes of algorithms for languages parsing based on multi-axiom grammars are developed: an algorithm obtained by generalizing context-free LR-parsers to multi-axiom grammars, and a pattern-matching algorithm that results from the ability to layer a multi-axiom language into levels such that each sublanguage is independent of the language that contains it. The implications of multi-axiom grammars for compiler code generation are briefly discussed.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The influence of language semantics on program slices

    Page(s): 120 - 127
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (574 KB)  

    The authors present observations on the influence of language semantics on program slices. These observations serve to illustrate that, whenever a program slice is designed for a specific language, the semantic features should be carefully examined, and the corresponding slicing algorithm adjusted accordingly. The authors can show that it is impossible to develop a single slicing routine which can be applied to all programming languages. In other words, a program slicer should be language-dependent. Its algorithm should be flexible enough to correspond to the semantics of a given language.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Generalized logical operators for temporal languages

    Page(s): 128 - 134
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (326 KB)  

    Previous proposals of temporal languages have used the standard TRUE/FALSE model of Boolean and comparison operators. Since this standard binary model introduces ambiguity as to which time value is desired, expressing nontrivial temporal conditions in these languages can be quite complicated. The authors' model overcomes this problem by generalizing the TRUE/FALSE model into one that uses sets of time intervals. The set-valued temporal logic satisfies the properties of the normal Boolean logic. The proposed logic can be very useful to different applications of temporal languages. Database query languages are used to demonstrate the effectiveness of the set-valued logic. The basic features of a relational-calculus query language based on the set-valued logic are presented. Applicability of the logic to relational-algebra query languages is discussed.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Experience with Rendezvous (tasking and communication model)

    Page(s): 143 - 149
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (476 KB)  

    BNR Pascal is a systems programming language that supports the Rendezvous model of tasking and communication. The authors discuss the BNR Pascal tasking model, their positive experience, areas of difficulty, and some of the BNR Pascal extensions that overcome the difficulties. They have found the Rendezvous model to be a powerful system structuring tool. In addition to its obvious uses in concurrency and interprocess communication, Rendezvous is useful in creating dynamic abstractions that are more powerful than traditional ones based on packages or modules. Additionally, tasks permit a capability-oriented style of resource protection. BNR Pascal extensions to the Rendezvous model include: a mechanism for deferring and reinitiating a Rendezvous, a nonblocking message-passing mechanism, and a mechanism for signaling events from lower to higher levels in a system.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • KSL: a reflective object-oriented programming language

    Page(s): 186 - 193
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (611 KB)  

    KSL (Knowledge Specification Language) is an object-oriented programming language that supports data abstraction, inheritance, and message-sending. KSL is also fully reflective, as a result of representing all of the language constructs as objects. Reflectivity allows the object paradigm to be applied to: the development, analysis, and translation of KSL; the extension of KSL to implement additional programming paradigms; and the development of applications that modify themselves. The authors provide an overview of KSL, its object representation, and how its reflectivity is achieved.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The precise control of inheritance and the inheritance of theory in the ADABTPL language

    Page(s): 194 - 201
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (657 KB)  

    It is possible to include robust inheritance features while separating them from data structuring mechanisms to a higher degree than is accomplished in most languages. The ADABTPL language does this by supplying a small class of orthogonal inheritance producing and restricting mechanisms. ADABTPL also supports a paradigm of programming by tying the compiler to a powerful Boyer-Moore-style theorem prover that can be invoked by the programmer to verify properties of programs and validate program transformations. This is accomplished by the use of higher-order functions and metatheorems to produce a tailored theory about particular programs.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Integrating abstract data types with object-oriented programming by specification-based approach

    Page(s): 202 - 209
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (431 KB)  

    The authors show that the integration of two popular automation-based paradigms, namely, ADT and OOP, can be used to achieve a high level of productivity and reliability. They introduce a system, Stim, (Small talk implementation for algebraic specification of abstract data types), that directly implements the algebraic specification of ADT on Smalltalk-80. Stim takes as an input a hierarchical algebraic specification and generates Smalltalk-80 classes automatically. The authors use an example of specifying a full-scale filing system to illustrate the power of the system.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object-oriented conceptual programming based on PROT nets

    Page(s): 226 - 233
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (591 KB)  

    The authors present PROTOB, an object-oriented computer-aided-software-engineering system based on high-level Petri nets called PROT nets. It consists of several tools supporting specification, modeling, and prototyping activities within the framework of the operational software-life-cycle paradigm. As its major application area it addresses discrete-event dynamic systems, such as process control systems and communication protocols.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object oriented programming (OOP) and its relevance to designing intelligent software systems

    Page(s): 242 - 248
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (663 KB)  

    The development of large software packages requires not only modularity but also the capability to experiment and change. Such a capability is akin to self-organization characteristics of adaptive systems. It is suggested that computer-aided software engineering (CASE) can benefit from the development retrainable software modules, where both the data structures and the algorithms performing on them are subject to evolutionary change. Such an approach is modeled after the AI (artificial-intelligence) methodology of reasoning by analogy, and it can be naturally implemented through the paradigm of object-oriented programming languages, which provide an exploratory software environment in which changes resulting from feedback to the system are easy to track and implement. The benefits of OOP to major software development areas involved with resource allocation, computer vision, and the service industry are discussed.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A naming specification language for syntax-directed editors

    Page(s): 250 - 257
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (713 KB)  

    A naming specification language, NSL, is described, which supplements existing syntax and semantics specification techniques for syntax-directed editor generation. NSL allows the editor implementor to define language-specific naming and scoping features in terms of a set of high-level abstractions. This facilitates editor generation by requiring considerably less work than either hand coding or specification using techniques more general than NSL. A modified editor-generator kernel architecture is described that efficiently implements the abstractions of NSL. This architecture supports NSL by a naming layer, which supplements the tree structure with graph edges, providing additional paths for semantic information propagation. The principal source of efficiency in this architecture is the direct propagation of incremental semantic evaluation from name declarations to name references. Also described are means by which NSL could be supported using previously proposed techniques for enhancing the performance of the attribute grammar paradigm.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A specification language for real-time distributed systems

    Page(s): 258 - 265
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (640 KB)  

    The authors introduce a design specification method, extended modified Petri nets (EMPN), and its description language (EMPNDL). The specification is based on a stochastic Petri-net model and is suitable for modeling real-time distributed systems. The syntax of the language is formally described in BNF grammar while the semantics is based on that for stochastic Petric nets. In addition to the modeling capability of EMPN and EMPNDL, methods for verification and validation of such systems are also discussed. EMPN and EMPNDL have been extensively used to the specification of a prototype switching system, UICPBX. Based on the presented formulation, verification and validation of UICPBX can be automated to a great extent.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • FLEX: towards flexible real-time programs

    Page(s): 272 - 279
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (657 KB)  

    The authors describe a language called FLEX, which makes it possible to program real-time systems that can respond to dynamic environments. In the worst case, when certain resources are not available, the program can produce approximate, imprecise results. This ability to write programs that are flexible in their execution time is provided by using constraints to express timing requirements, and sieves and imprecise values to obtain imprecise results. The authors discuss the semantic aspects of computing with imprecise values.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • TXL: a rapid prototyping system for programming language dialects

    Page(s): 280 - 285
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (409 KB)  

    A rapid prototyping system for extensions to an existing programming language is described. Such extensions could include language features or could introduce notation specific to a particular problem domain. The system consists of a dialect description language used to specify the syntax and semantics of extensions and a context-sensitive syntactic transducer that automatically implements the extensions by transforming source programs written using them to equivalent programs in the original unextended language. Because the transformer is context-sensitive, it is more powerful than traditional context-free preprocessors and extensible languages, and can be used to prototype language extensions involving significantly novel programming paradigms such as object-oriented programming.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Array theory, logic and the Nial language

    Page(s): 296 - 303
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (517 KB)  

    A logical description of arrays is developed, indicating that it is possible to incorporate array data structures into a theory that builds on the conventional theory of lists. This theory provides a basis for the functional programming language Nial. An emphasis in the development of Nial has been to explore ways to integrate the logic programming paradigm with the functional-programming and array-handling capabilities of the language. By providing a logical basis for array theory, the authors have provided a formal basis for the development of a semantics for logic programming with arrays in Nial.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Languages for intelligent specification systems

    Page(s): 304 - 311
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (438 KB)  

    By writing specifications as theories of a logic system, the authors use proof theory to ensure that (a) the consequences of theory are properties of the object being specified, and (b) any known property of the object can be proven as a theorem of the theory. They define an extension of first-order logic that deals with events with actions. The resulting logic is a special type of modal logic with a notation similar to that of Hoare-style logics. Specifications are theories of this logic.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visual languages and software specifications

    Page(s): 322 - 328
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (459 KB)  

    The important issues and major features of visual languages are summarized, and their impact on software engineering, especially software specification techniques, are discussed. The potential of using visual languages for software specifications to improve software reliability, modifiability, reusability, and understandability is also considered.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Architectural design methodology for supporting high level programming languages

    Page(s): 356 - 363
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (579 KB)  

    The authors present two of the tasks that must be carried out in the proposed design methodology: the selection and grouping of high-level programming languages (HLPLs) and the selection of hardware structure(s) for each group of HLPLs for the purpose of architectural design. Each group of HLPLs will have its own distinct architecture. Only the grouping of HLPLs and selection of structures for one of the groups of HLPLs is treated. Grouping HLPLs is required to support several HLPLs efficiently and to eliminate the effects of semantic clash that exists between HLPLs, which will improve execution efficiency and software reliability.<> View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.