Programming language concepts for multiprocessors

It is currently possible to build multiprocessor systems which will support the tightly coupled activity of hundreds to thousands of different instruction streams, or processes. This can be done by coupling many monoprocessors, or a smaller number of pipelined multiprocessors, through a high concurrency switching network. The switching network may couple processors to memory modules, resulting in a shared memory multiprocessor system, or it may couple processor/memory pairs, resulting in a distributed memory system.

The need to direct the activity of very many processes simultaneously places qualitatively different demands on a programming language than the direction of a single process. In spite of the different requirements, most languages for multiprocessors have been simple extensions of conventional, single stream programming languages. The extensions are often implemented by way of subroutine calls and have little impact on the basic structure of the language. This paper attempts to examine the underlying conceptual structure of parallel languages for large-scale multiprocessors on the basis of an existing language for shared memory multiprocessors, known as the Force, and to extend the concepts in this language to distributed memory systems.     

Robot language from the standpoint of FA system development—An outline of FA-BASIC

A new unified FA (Factory Automation) language has been developed. The language is suited for robot control, vision system control and programmable controller (PC) control and enables a unified means for programming. The language is called FA-BASIC and has common functions such as expression, control structure and input/output statement based on BASIC language.

FA-BASIC is composed of three subsystems: FA-BASIC/R for robot control, FA-BASIC/V for vision system control and FA-BASIC/C for PCs.

Many languages have been developed up to now, but most of them were aimed at single purposes. These single purpose languages were too limited when developing an integrated FA system, because several languages and different program-making methods must be mastered.

Using FA-BASIC, programming with mutual interconnections between robots, PCs and vision devices is done by the one common method.

In this paper, the basic design concept and functions of FA-BASIC will be presented, along with the features of FA-BASIC/R and on outline of a robot control system using a standard mechanism-independent intermediate language and standard fundamental modules. Also, for easy programming, an off-line programming system with graphical aids and a menu-selection method which require no special effort to master will be introduced as the only present-day universal robot programming method.     

Mixed language programming

Subroutines for numerical computation have in the past been written mainly in Fortran and in Algol 60, whereas most programming in the future is expected to be in more advanced languages, for example in Ada. It seems to be a great waste if it will become necessary to convert all existing numerical software into the new languages. What is needed is a facility to include subroutines written in the old languages into programs being written in the newer languages. In this paper an automatic procedure to facilitate the use of mixed languages is suggested, the purpose of the paper is to indicate the desirability for providing the required facilities, and to encourage discussion and further research in the area of mixed language programming.     

Dynamic security labels and static information flow control

This paper presents a language in which information flow is securely controlled by a type system, yet the security class of data can vary dynamically. Information flow policies provide the means to express strong security requirements for data confidentiality and integrity. Recent work on security-typed programming languages has shown that information flow can be analyzed statically, ensuring that programs will respect the restrictions placed on data. However, real computing systems have security policies that cannot be determined at the time of program analysis. For example, a file has associated access permissions that cannot be known with certainty until it is opened. Although one security-typed programming language has included support for dynamic security labels, there has been no demonstration that a general mechanism for dynamic labels can securely control information flow. In this paper, we present an expressive language-based mechanism for reasoning about dynamic security labels. The mechanism is formally presented in a core language based on the typed lambda calculus; any well-typed program in this language is secure because it satisfies noninterference.     

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.     

Using B SP and Python to simplify parallel programming

Scientific computing is usually associated with compiled languages for maximum efficiency. However, in a typical application program, only a small part of the code is time-critical and requires the efficiency of a compiled language. It is often advantageous to use interpreted high-level languages for the remaining tasks, adopting a mixed-language approach. This will be demonstrated for Python, an interpreted object-oriented high-level language that is well suited for scientific computing. Particular attention is paid to high-level parallel programming using Python and the BSP model. We explain the basics of BSP and how it differs from other parallel programming tools like MPI. Thereafter we present an application of Python and BSP for solving a partial differential equation from computational science, utilizing high-level design of libraries and mixed-language (Python–C or Python–Fortran) programming.     

Database query languages and functional logic programming

Functional logic programming is a paradigm which integrates functional and logic programming. It is based on the use of rewriting rules for defining programs, and rewriting for goal solving. In this context, goals, usually, consist of equality (and, sometimes, inequality) constraints, which are solved in order to obtain answers, represented by means of substitutions. On the other hand, database programming languages involve a data model, a data definition language and, finally, a query language against the data defined according to the data model. To use functional logic programming as a database programming language, (1) we will propose a data model involving the main features adopted from functional logic programming (for instance, handling of partial and infinite data), (2) we will use conditional rewriting rules as data definition language, and finally, (3) we will deal with equality and inequality constraints as query language. Moreover, as most database systems, (4) we will propose an extended relational calculus and algebra, which can be used as alternative query languages in this framework. Finally, (5) we will prove that three alternative query languages are equivalent.     

A domain-specific language for regular sets of strings and trees

We propose a novel high level programming notation, called FIDO, that we have designed to concisely express regular sets of strings or trees. In particular, it can be viewed as a domain-specific language for the expression of finite state automata on large alphabets (of sometimes astronomical size). FIDO is based on a combination of mathematical logic and programming language concepts. This combination shares no similarities with usual logic programming languages. FIDO compiles into finite state string or tree automata, so there is no concept of run-time. It has already been applied to a variety of problems of considerable complexity and practical interest. We motivate the need for a language like FIDO, and discuss our design and its implementation. Also, we briefly discuss design criteria for domain-specific languages that we have learned from the work with FIDO. We show how recursive data types, unification, implicit coercions, and subtyping can be merged with a variation of predicate logic, called the Monadic Second-order Logic (M2L) on trees. FIDO is translated first into pure M2L via suitable encodings, and finally into finite state automata through the MONA tool     

A lingua franca for concurrent logic programming

Two of the more important concurrent logic programming languages with nonflat guards are GHC and Parlog. They balance the requirements of having clean semantics and providing good control facilities rather differently, and their respective merits are compared and contrasted. Since concurrent logic programming would benefit from both, but neither language is able to express all the programs expressible in the other language, a lingua franca of these languages is defined and justified. A method is given for translating GHC and Parlog to and from it. The method preserves the arities and execution conditions of each clause. It enables a lingua franca implementation to support both languages transparently, and to provide a simple concurrent logic programming language suitable for programming in its own right     

A new programming paradigm for engineering design software

Currently available programming and database systems are insufficient for engineering applications. The authors contend that a logical progression from a formal conceptual model of the engineering domain to a computational model will lead to new programming paradigms capable of directly supporting engineering applications in a rigorous, concise manner. A formal domain model devised by the authors, theHybrid Model (HM) of design information, is briefly introduced. It is an extension of axiomatic set theory and is discussed in detail elsewhere. HM forms the basis ofDesigner, a prototype-based object-oriented programming language supporting a signature-based canonical message-passing mechanism and multiple inheritance. Designer is implemented using the Scheme programming language. Because Designer satisfies a formal conceptual model, and because it is based on a formally specified language, its robustness and logical validity are superior to those of other languages not founded on formal principles. Designer combines concepts of functional and object-oriented programming to provide the formal rigor and flexibility to capture the complex and strongly interrelated information that designers use. Examples demonstrate how Designer represents design information. The results of the authors' research indicate that Designer can capture design information (including aspects of functional requirements and design intent) effectively and efficiently.     

Design of an arabic programming language (ARABLAN)

It was observed that school children in Arab countries find difficulty in learning programming in a language other than their native language. There are only few Arabic programming languages in the literature; most of which are never or partially implemented. In this paper, we present the design of a new Arabic programming language (ARABLAN) which is planned to be implemented for use in teaching programming for school children in Arab countries.     

Some Approaches to, and Illustrations of, Programming Language History

This paper describes some factors in, approaches to, and specific elements of, programming language history. It first lists a number of general factors and approaches which can be used to discuss the history of programming languages. After presenting a life cycle for programming language development, it provides numerous illustrations of programming language history and chronology from many of the viewpoints indicated earlier. There is a brief discussion of relevant literature and a section indicating some of the reasons for the vast proliferation of programming languages. Various charts and lists are included. This paper should be viewed as one approach to considering the history of programming languages, rather than as a history of programming languages per se.     

汇编语言在当今软件设计领域中能否生存

汇编语言是一门低级程序设计语言,它主要的功能是直接对硬件进行控制.虽然它是一门面向机器的语言,在可读性和移植性方面不及高级程序设计语言好,但用它所编写出来的程序能够在各种控制芯片上直接执行,具有效率高、反应快的特点,这是其它高级程序设计语言所无法超越的,所以汇编语言在当今软件设计领域中是无法被其它高级程序设计语言所替代的.     

Design dysphasia and the pattern maintenance cycle

Software developers utilize design methods that enable them to manipulate conceptual structures that correlate to programming language features. However, programming languages and the programming paradigms they embody co-evolve over time. Within industrial and academic circles, for example, object-oriented programming has evolved and effectively replaced imperative programming. More recently, many object-oriented languages have assimilated features from other programming paradigms, evolving into multiparadigm languages we refer to as ‘object-oriented plus–plus’ or OO++. This language evolution may weaken the interface between design and implementation, introducing what we call ‘design dysphasia’—a partial disability in the use of a programming language because of incongruous design methods. Software design patterns capture elements of reusable design within a specific context. When the programming languages that are part of pattern context evolve, patterns must adapt to the language change or they may reinforce design dysphasia in the practitioner. We assert that the current ‘capture/recapture’ pattern maintenance model is suboptimal for adapting patterns to language evolution and propose a new ‘capture/modify/recapture’ maintenance cycle as a more effective approach. We then suggest a concrete ‘modify’ phase for current patterns to be adapted to object-oriented based multiparadigm language trends. We present an OO++ Iterator pattern as an example throughout.     

A proposal to merge Multiple Tuple Spaces,Object Orientation,and Logic Programming

We define a new language that naturally satisfies the requirements of concurrency support, modularity, and declarativity. Although some classes of existing languages already cover a subset of these requirements, there is no example of a programming language entirely fulfilling them. We propose to merge three programming paradigms, Multiple Tuple Spaces, Object Orientation, and Logic Programming, as a solution to our requirement list. Each paradigm is well characterized and satisfies one of the given requirements. Moreover, we claim that the merging will reveal new directions in the inception and development of future programming languages.     

An Approach to Platform Independent Real-Time Programming: (1) Formal Description

A method for extending programming languages with timing constructs is proposed. It enables the specification of timing constraints in programs. The approach is not language specific and the extension can be included in many existing programming languages. With the extension it is possible to write real-time program components that can be proven correct independently of the properties of the machine that is used for their execution. It therefore provides a similar abstraction from the execution platform as is normal in non-real-time programming. The presented approach distinguishes two phases in system construction: (1) a platform-independent programming phase that includes the expression of timing requirements, and (2) an implementation phase where all platform dependencies are addressed. The latter only differs from a normal compilation in the sense that a feasible schedule must be found to execute the program.     

用于漏洞检测的中间语言表示方法

现有Web漏洞检测方法中使用的中间语言针对特定编程语言设计,在对多种编程语言源代码进行漏洞抽象表示时,无法将多语言下的同类型漏洞用统一的中间语言表示,增加了后续漏洞分析处理的难度。针对该问题提出了一种基于污点分析的中间语言表示方法,实现多编程语言下同类型漏洞信息的统一抽象表示。该中间语言设计过程中将漏洞发生过程抽象为三元组表示,将与三元组相关的代码元素抽象为中间语言的关键字,根据三元组间的语义关系设计了该中间语言的语法。在转义时,利用污点分析方法跟踪污染源的执行路径,对路径中的源代码进行转义得到中间语言表示。最后将该中间语言用于漏洞检测模型,实验结果表明该中间语言与对照中间语言相比对编程语言中漏洞信息的抽象表示更具普适性,对漏洞检测具有有效性。     

Studying the language and structure in non-programmers' solutions to programming problems

Programming may be more difficult than necessary because it requires solutions to be expressed in ways that are not familiar or natural for beginners. To identify what is natural, this article examines the ways that non-programmers express solutions to problems that were chosen to be representative of common programming tasks. The vocabulary and structure in these solutions is compared with the vocabulary and structure in modern programming languages, to identify the features and paradigms that seem to match these natural tendencies as well as those that do not. This information can be used by the designers of future programming languages to guide the selection and generation of language features. This design technique can result in languages that are easier to learn and use, because the languages will better match beginners' existing problem-solving abilities.     

A practical comparison of two object-oriented languages

The author compares two very different object-oriented programming languages, Flavors and C++, with respect to their merits and how design decisions in each language influence various aspects of programming. The fundamental difference between the two languages is that C++ is strongly typed while Flavors is weakly typed. The comparison follows the completion of two very similar programming projects, one using Flavors and the other C++, allowing direct comparison of software implementation methods in these languages. The projects involved the design of two systems for describing and generating electronic hardware. Differences in implementing all three object-oriented language mechanisms-data abstraction, inheritance, and runtime method determination-are discussed. Typing, memory management, syntax aids and the programming environment are examined. It is concluded that the choice of a language can have a profound influence on program design.<>