Programming with partially specified aggregates in Java

Various forms of data aggregates, e.g., arrays, lists, sets, etc., are usually provided by programming languages, either as primitive entities or as additional features made available by standard libraries. In conventional programming languages these data structures are usually specified by completely and precisely enumerating all their constituent elements. Conversely, in (constraint) logic programming languages it is common to deal with partially specified aggregates where either some elements or some parts of the aggregate are left unknown. In this paper we consider the case where partially specified aggregates can occur in a conventional O-O programming language. Specifically, we consider partially specified lists and sets as provided by the Java library JSetL. The definition of such data structures is strongly based on the notion of logical (or constrained) variable usually provided by languages and libraries to support constraint programming. We show through simple examples using Java and JSetL how partially specified lists and sets, along with a few basic constraints over them, can be conveniently exploited in a number of common programming problems.     

并行程序设计语言发展现状

In this paper we introduce the history of the parallel programming language and list some of currently parallel programming languages. Then according to the classified principle. We analyze some of the representative parallel programming languages in detail. Finally, we show a further feature to the parallel programming language.     

Multilanguage Programming

Knowing and using multiple programming languages for normal day-to-day development can yield significant benefits. No single language is a great fit for all problems. A programming language usually owes its existence to one simple fact: its designer felt it could address a set of problems - perhaps even just one problem - better than other available languages. This belief is apparently not uncommon: thousands of languages have come and gone and thousands more will follow. Numerous trade-offs are involved in programming language design and development, so there's room for many different approaches and variants. Unsurprisingly, monolingual developers tend to choose general-purpose rather than specialized programming languages. General-purpose languages perform adequately for a wide variety of problems, but they generally yield predominantly middle-of-the-road solutions - neither great nor terrible. Of course, some monolingual developers possess extremely deep and thorough knowledge of their programming languages, and so know how to exploit them to the fullest.     

An evaluation of programming languages and language features for engineering software development

This article addresses the need for engineers to have a working knowledge of the fundamental structures of computer programming languages. In pursuit of this, it briefly looks at the history behind four of the more well-known programming languages. It then attempts to identify, and to look critically at, the attributes of programming languages that significantly affect the production of engineering software. The four traditional procedural programming languages chosen for review are those intended for scientific and general purpose programmin—FORTRAN-77, C, Pascal, and Modula-2. These languages are compared and some general observations are made.The emphasis of this article is on the attributes, characteristics, and components of programming languages that are important to software development and maintenance. Consequently, the comparison itself is of secondary importance, with the actual methodology of comparison given prominence in order that professional engineers who need to develop engineering software are able to make rational decisions about the choice of a programming language. Choosing an appropriate language can be a complex task and many factors must be considered. Therefore, in this article the fundamental structures, constructs, and attributes of programming languages are discussed, with very little attention given to the specific syntax of any particular language.     

MODELS AND TRENDS IN PARALLEL PROGRAMMING

This paper introduces and discusses programming models for parallel processing and recent trends in the area of parallel programming. The paper discusses different parallel programming languages and tools that reflect various parallel computation models. These language differ in expressiveness, portability and performance. Software design and implementation largely varies by using different languages that make the programmer task easy or complex. We describe here the design goals and the main issues of parallel programming models and languages belonging to the following categories: shared-space based languages, message-based languages, parallel toolkits, data-parallel languages, parallel declarative languages, parallel object-oriented languages, and parallel composition-based languages. Tools and languages such as HPF, Linda, Java, OpenMP, PVM, MPI, Parallel C+ +, Sisal, Orca, Mentat, SkieCL, BSP and others are described in some detail. Their main features for design and implementation of high performance applications are discussed. Finally, we outline directions of research and development in the parallel programming area with a special attention to novel approaches based on high-level programming structures that make transparent to the users the architectural details of parallel computing machines.     

Unified selection from lists,arrays, and objects

The first language computer science students learn, more often than not, is a common production language such as C++ or Java. A minority of curricula, however, begin with a language, such as Scheme, assumed to be a better framework for teaching about computation. SWAY is an experimental teaching language, as expressive as Scheme, but provides an easier transition to production languages. It is a functional language at its core, but adds assignment and a simple object system. One of the goals of SWAY is to incorporate C-style syntax, but to vary from that syntax when pedagogical or ease of programming needs arise. One such area that SWAY differs from languages with C-like expressions is in the selection of items from homogeneous and heterogeneous aggregates. Much like the overloading of the plus operator to add integers as well as reals, a single operator is used for selection in SWAY, regardless of the aggregate structure. It is shown that taking such an approach naturally eases the burden of moving from arrays to objects to lists, in any order, both in teaching and programming.     

Forward chaining in HALO: An implementation strategy for history-based logic pointcuts

In aspect-oriented programming, pointcuts are formulated as conditions over the context of dynamic events in the execution of a program. Hybrid pointcut languages also allow this context to come from interactions between the pointcut language and the base program. While some pointcut languages only allow conditions on the current execution event, more recent proposals have demonstrated the need for expressing conditions over a history of join points. Such pointcut languages require means to balance the expressiveness of the language with the additional memory and runtime overhead caused by keeping a history of join point context data. In this paper, we introduce a logic-based pointcut language that allows interaction with the base program as well as pointcuts over a history of join points. We introduce forward chaining as an implementation model for this language, and discuss possible optimization strategies for the additional overhead.     

History and future of FORTRAN

FORTRAN is one of the most widely used programming languages in the scientific sector. This article examines FORTRAN and its history and gives some clues to the success of the language in the light of more modern programming languages. The common thread, where any, is that of problem solving and programming using a computer system.     

Computer system simulation in Pascal

The programming language Pascal is considered as one of the most interesting computer system simulation tools. This paper discusses design facilities required in simulation languages, making use of a model described in Pascal. An important area is seen to be that of queues, lists or sets, and the facilities that are powerful yet simple to use are stressed. The problem of parallelism and synchronization in a simulator is solved. The structure of the simulator is considered.     

A programming language for learning environments

Most of the recent research on programming languages for education has been centered around the language Logo. In this paper we introduce another candidate language for learning environments, Nial, the nested interactive array language.
Nial is a general-purpose programming language based on a formal theory of mathematics called array theory. This paper introduces Nial as a language for learning programming and developing and using computer-aided instruction tools. A comparison with Logo is provided to evaluate these two languages in terms of their strengths and weaknesses as programming environments for novice programmers. We also demonstrate that a programming environment can be both simple to leam at the novice level and extendible to a powerful and sophisticated language.     

Konrad Zuse's Plankalku¨l: the first high-level, “non vonNeumann” programming language

Konrad Zuse was the first person in history to build a working digital computer, a fact that is still not generally acknowledged. Even less known is that in the years 1943-1945, Zuse developed a high-level programming model and, based on it, an algorithmic programming language called Plankalku¨l (Plan Calculus). The Plankalku¨l features binary data structure types, thus supporting a loop-free programming style for logical or relational problems. As a language for numerical applications, Plankalku¨l already had the essential features of a “von Neumann language”, though at the level of an operator language. Consequently, the Plankalku¨l is in some aspects equivalent and in others more powerful than the von Neumann programming model that came to dominate programming for a long time. To find language concepts similar to those of the Plankalku¨l, one has to look at “non-von Neumann languages” such as APL or the relational algebra. This paper conveys the syntactic and semantic flavor of the Plankalku¨l, without presenting all its syntactic idiosyncrasies. Rather, it points out that the Plankalku¨l was not only the first high-level programming language but in some aspects conceptually ahead of the high-level languages that evolved a decade later     

An APL approach to the representation and manipulation of data structures

One of the important characteristics of a programming language is the manner in which commonly used data structures can be represented and manipulated. Methods for the representation of complex data structures in APL, a programming language based on rectangular arrays and a multiplicity of functions, are presented in this paper. Data structures considered are: strings and sets, stacks and queues, tables, linked lists, and sort trees. The material provides insight into the nature of data structures and should aid in establishing future requirements for primal and base languages.     

Emerald: A general-purpose programming language

Emerald is a general-purpose language with aspects of traditional object-oriented languages, such as Smalltalk, and abstract data type languages, such as Modula-2 and Ada. It is strongly typed with a non-traditional object model and type system that emphasize abstract types, allow separation of typing and implementation, and provide the flexibility of polymorphism and subtyping with compile-time checking. This paper describes the Emerald language and its programming methodology. We give examples that demonstrate Emerald's features, and compare and contrast the Emerald approach to programming with the approaches used in other similar languages.     

Design, construction, and application of a generic visual languagegeneration environment

The implementation of visual programming languages (VPLs) and their supporting environments is time-consuming and tedious. To ease the task, researchers have developed some high-level tools to reduce the development effort. None of these tools, however, can be easily used to create a complete visual language in a seamless way as the lex/yacc tools do for textual language constructions. This paper presents the design, construction and application of a generic visual language generation environment, called VisPro. The VisPro design model improves the conventional model-view-controller framework in that its functional modules are decoupled to allow independent development and integration. The VisPro environment consists of a set of visual programming tools. Using VisPro, the process of VPL construction can be divided into two steps: lexicon definition and grammar specification. The former step defines visual objects and a visual editor, and the latter step provides language grammars with graph rewriting rules. The compiler for the VPL is automatically created according to the grammar specification. A target VPL is generated as a programming environment which contains the compiler and the visual editor. The paper demonstrates how VisPro is used by building a simple visual language and a more complex visual modeling language for distributed programming     

POP, A Broad-Spectrum Programming Language, 1967–2002

This paper discusses the POP-2 language and Multipop time-sharing system developed during the second half of the 1960s. POP-2's expressiveness spanned numeric and symbolic programming and supported experiments in logic of programming languages (by Boyer and Moore) and programming language concepts (for example, Michie's memoisation). The paper also discusses how the goals of POP-2 might be achieved in a successor language. Received October 2000 / Accepted in revised form January 2002     

不同编程语言对计算机软件开发的影响

文章通过阐述计算机常用的编程语言,分析不同编程语言对计算机软件开发的影响,对计算机软件开发中编 程语言选择相关注意事项展开探讨,旨在为促进计算机软件开发中编程语言的合理选择提供一些思路。     

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.     

基于产生式的多语言程序理解的算法

提出一种程序理解实现方案,通过将程序设计语言的词法规则和语法规则以产生式表示,设计基于产生式多语言程序处理算法,将产生式自动转化为对应的词法和语法规则函数,使得不同的程序设计语言规则可以采用统一的方式描述,从而可用一套程序理解系统实现对多种程序设计语言的程序理解,以后增加某种程序设计语言的程序理解,只要定义对应程序设计语言的词法和语法规则产生式即可实现,有效地解决了程序理解系统的共享性难题。