Computer Languages最新文献

An executable specification language, known as PSP, for fast prototyping parallel responsive systems is introduced. The language is equipped with directly executable mathematical data objects, first order predicates, temporal operators, parallel assignment, state and state history, sets, maps and sequences, etc. An abstract system model of a parallel responsive systems may be constructed using PSP. Using this model, various dynamic behaviors of the system can be studied and analysed at an early design stage. These include detailed temporal relations between every component in the system. Temporal and functional properties of the system can also be expresse within PSP as (temporal) predicates. Global cause-effect relations and other temporal properties of the system can be tested by executing both the abstract system model and its associated functional/temporal asscertions. Inconsistency an incompleteness in the abstract design can then be discoverd against user's intention before real implemention, thus reducing design cost. PSP is illustrated using a lift system.

This paper describes the results of a large empirical study to measure the run-time behavior of Quicksort by using various methods of computing the pivot element for medium to large size randomly generated integer data. The results of our study contradict the common notion that Quicksort gives best performance if median of three scheme is used to compute the pivot element and array partitions having < 10 elements are sorted by using insertion sort. It was found that Quicksort performs best when median of three scheme is used to decide the pivot element and arrays with < 4 elements are hand sorted. Our method gives an average speedup of > 9% when compared to the method with a cutoff of 10 and sub-arrays with < 10 elements insertion sorted for 1000 ⩽ N 1.5 × 10⁶. Our study shows that advanced hardware features allow for implementation of very fast codes for sorting small arrays, and using such codes instead of insertion sort can lead to substantial improvements for Quicksort, as conjectured by Sedgewick many years ago.

There have been a number of models proposed for integrating concurrency and object-oriented programming. Unfortunately, there have been few criteria proposed for evaluating them. In focusing on issues of inheritance, designers of new concurrent object-oriented programming languages appear to have forgotten the experiences learned from over two decades of concurrent programming. In this paper we review Bloom's criteria for evaluating the expressive power of synchronisation primitives, and apply it in an object-oriented framework. We show that most of the available concurrent object-oriented programming languages lack expressive power, and that this contributes to the so-called inheritance anomaly. We then propose a new model which does address all of Bloom's criteria.

Lexical analyzers partition input characters into tokens. When ambiguities arise during lexical analysis, the longest-match rule is generally adopted to resolve the ambiguities. The longest-match rule causes the look-ahead problem in traditional lexical analyzers, which are based on Moore machines. In Moore machines, output tokens are associated with states of the automata. By contrast, because Mealy machines associate output tokens with state transitions, the look-ahead behaviors can be encoded in their state transition tables. Therefore, we believe that lexical analyzers should be based on Mealy machines, rather than Moore machines, in order to solve the look-ahead problem. We propose techniques to construct Mealy machines from regular expressions and to perform sequential and data-parallel lexical analysis with these Mealy machines.

An increasing range of application systems implemented in concurrent object oriented languages (COOLs) creates a pressing demand for developing approaches which provide a systematic way of tolerating software and hardware faults by using software diversity. This paper deals with the problem of tolerating faults in concurrent systems of this type. The purposes of this paper are as follows: to discuss the most appropriate ways of implementing conversations in COOLs; to map all attributes of conversations onto these languages; to discuss the most relevant peculiarities of COOLs in these terms; to suggest approaches to using the conversation scheme; to find the ways in which characteristics of COOLs can facilitate the use of conversation schemes. Thus we try to show how conversations can be used in existing COOLs in a more practical and realistic manner.

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.

Due to the unique requirements of a series of projects to specify communications architectures using graphical representations (Cara and MFD), we have developed the communications-oriented rule-based language Carla (Cara Rule Language), which provides an executable specification of the architecture being developed. Carla is designed to provide the ability to specify and simulate high-level, possibly incomplete, specifications of communications architectures, and to allow the developer to refine the specification through the addition of behavior-describing rules. Carla is also well-suited to creating black-box specifications of any system whose behavior depends on input/output history. We describe the features of the language, discuss various design issues, and provide examples of various communications protocols specified in Carla.

This paper presents a method for statically verifying that functions do not produce side-effects, in an object-oriented language. The described model, although not allowing any changes to pre-existing objects during a function call, permits an imperative style of programming, where new objects can be freely created and manipulated.

In this paper we introduce a formal model of the object-oriented programming language SMALLTALK-80. The model can be useful for different applications in the framework of language design and implementation like compiter or interpreter generation, correctness proofs of the implementations, and standardization of the language.