Search

JavaScript is the most popular programming language for the Web. Although the language is prototype-based, developers can emulate class-based abstractions in JavaScript to master the increasing complexity of their applications. Identifying classes in legacy JavaScript code can support these developers at least in the following activities: (1) program comprehension; (2) migration to the new JavaScript syntax that supports classes; and (3) implementation of supporting tools, including IDEs with class-based views and reverse engineering tools. In this paper, we propose a strategy to detect class-based abstractions in the source code of legacy JavaScript systems. We report on a large and in-depth study to understand how class emulation is employed, using a dataset of 918 JavaScript applications available on GitHub. We found that almost 70% of the JavaScript systems we study make some usage of classes. We also performed a field study with the main developers of 60 popular JavaScript systems to validate our findings. The overall results range from 97% to 100% for precision, from 70% to 89% for recall, and from 82% to 94% for F-score. [ABSTRACT FROM AUTHOR]

Until about 1970, programming languages and their compilers were perhaps the most active system software area. Because of its technical position at that time, IBM made significant contributions to this field. This retrospective concentrates on two languages, Algol 60 and PL/I, because with them compiler development reached an historical peak within IBM's European laboratories. The Boeblingen, Hursley, and La Gaude labs were involved in compiler projects for a period of 10 to 15 years. This article considers the development of programming in general, the author's experience, and the responsibility of the different laboratories. As a consequence of IBM's "unbundling"' decision in 1969, programming language activity within IBM's European laboratories decreased considerably, and other software activities were initiated. Some of the lessons learned at that time are still useful today. [ABSTRACT FROM PUBLISHER]

Agents in a multiagent system may in many cases find themselves in situations where inconsistencies arise. In order to properly deal with these, a good belief revision procedure is required. This paper illustrates the usefulness of such a procedure: a certain belief revision algorithmis considered in order to deal with inconsistencies and, particularly, the issue of inconsistencies, and belief revision is examined in relation to the GOAL agent programming language. [ABSTRACT FROM AUTHOR]

We present SNIP, an efficient model checker for software product lines (SPLs). Variability in software product lines is generally expressed in terms of features, and the number of potential products is exponential in the number of features. Whereas classical model checkers are only capable of checking properties against each individual product in the product line, SNIP exploits specifically designed algorithms to check all products in a single step. This is done by using a concise mathematical structure for product line behaviour, that exploits similarities and represents the behaviour of all products in a compact manner. Specification of an SPL in SNIP relies on the combination of two specification languages: TVL to describe the variability in the product line, and fPromela to describe the behaviour of the individual products. SNIP is thus one of the first tools equipped with specification languages to formally express both the variability and the behaviours of the products of the product line. The paper assesses SNIP and suggests that this is the first model checker for SPLs that can be used outside the academic arena. [ABSTRACT FROM AUTHOR]

This paper reviews the robotic development trends, its sophistication and reduction of obscurity which is continuously improving. At present, most of the researchers are focused on reactive robotics rather than deliberative for various flexibilities and avoidance of complexity. The paper reviews the reasons behind the high adoption of behavior based robotics in the field of autonomous machine. It then makes a critical argument for the role of deliberative mobile robots. Analysis of the underlying combination of behavior-based autonomous machine and robotic control languages is then presented. This paper will be of interest to experts in robotics, and those building macro languages to aid robotic movement. [ABSTRACT FROM AUTHOR]

Mnemonics is a Scala library for generating method bodies in JVM bytecode at run time. Mnemonics supports a large subset of the JVM instructions, for which the static typing of the generator guarantees the well-formedness of the generated bytecode. The library exploits a number of advanced features of Scala's type system (type inference with bounded polymorphism, implicit parameters, and reflection) to guarantee that the compiler only accepts legal combinations of instructions at compile time. Additional instructions are supported at the price of a check at run time of the generator. In either case, bytecode verification of generated code is guaranteed to succeed. [ABSTRACT FROM AUTHOR]

The paper describes a new library developed for Linda language implementation for Scala programming language (language support of the component programming software). The library uses client-server architecture and a database for the tuple space representation. It implements the search for similarities and “primitive” and additional operations. The library can be used for distributed and parallel application development. [ABSTRACT FROM AUTHOR]

This article develops a proof theory for low-level code languages. We first define a proof system, which we refer to as the sequential sequent calculus, and show that it enjoys the cut elimination property and that its expressive power is the same as that of the natural deduction proof system. We then establish the Curry-Howard isomorphism between this proof system and a low-level code language by showing the following properties: (1) the set of proofs and the set of typed codes is in one-to-one correspondence, (2) the operational semantics of the code language is directly derived from the cut elimination procedure of the proof system, and (3) compilation and decompilation algorithms between the code language and the typed lambda calculus are extracted from the proof transformations between the sequential sequent calculus and the natural deduction proof system. This logical framework serves as a basis for the development of type systems of various low-level code languages, type-preserving compilation, and static code analysis. [ABSTRACT FROM AUTHOR]

Fingerprinting embeds a secret message into a cover message. In media fingerprinting, the secret is usually a copyright notice and the cover a digital image. Fingerprinting an object discourages intellectual property theft, or when such theft has occurred, allows us to prove ownership. The Software Fingerprinting problem can be described as follows. Embed a structure W into a program P such that: W can be reliably located and extracted from P even after P has been subjected to code transformations such as translation, optimization and obfuscation; W is stealthy; W has a high data rate; embedding W into P does not adversely affect the performance of P; and W has a mathematical property that allows us to argue that its presence in P is the result of deliberate actions. In this article, we describe a software fingerprinting technique in which a dynamic graph fingerprint is stored in the execution state of a program. Because of the hardness of pointer alias analysis such fingerprints are difficult to attack automatically. [ABSTRACT FROM AUTHOR]

We present a unified mathematical framework for analyzing the tradeoffs between parallelism and storage allocation within a parallelizing compiler. Using this framework, we show how to find a good storage mapping for a given schedule, a good schedule for a given storage mapping, and a good storage mapping that is valid for all legal (one-dimensional affine) schedules. We consider storage mappings that collapse one dimension of a multidimensional array, and programs that are in a single assignment form and accept a one-dimensional affine schedule. Our method combines affine scheduling techniques with occupancy vector analysis and incorporates general affine dependences across statements and loop nests. We formulate the constraints imposed by the data dependences and storage mappings as a set of linear inequalities, and apply numerical programming techniques to solve for the shortest occupancy vector. We consider our method to be a first step towards automating a procedure that finds the optimal tradeoff between parallelism and storage space. [ABSTRACT FROM AUTHOR]

The Province of Manitoba is constructing a terminal network to provide computer facilities to high schools. In order to minimize costs, optical mark card readers have been installed. The authors have designed an optical mark card with specific emphasis on coding programs in FORTRAN, COBOL, PL/1, and ALGOL. The card uses an encoding scheme designed to minimize marking effort. In particular, most keywords are included and may be obtained by a single column marking which can be determined from the keyword. A correction facility permits modification to an existing optical or keypunched card by the addition of a correction card. A right and left tabbing facility similar to the typewriter tab is included. A first approximation to this card design has been used at the University of Manitoba in 1972-3 and the revised card is being used in both the University and in the Manitoba High School system in 1973-4. [ABSTRACT FROM AUTHOR]

This tutorial paper is presented at an intermediate level, which assumes that the reader already has either some elementary knowledge of PL/I or a more general familiarity with other high level languages. An attempt is made to break fresh ground by addressing a question concerning the design philosophy of PL/I, namely whether it is possible for the more experienced programmer to grasp the deeper structure and achieve complete mastery of a language with such broad scope. (It is not concerned with showing how easily parts of the language may be used for simple applications, although several introductory texts are cited.) The method of the exposition is first to dispose of certain preprocesses which may be performed, and then to organize the major part of the material under two heads, static aspects and dynamic aspects. The static aspects are those essentially related to inspection rather than execution of a program; the dynamic part of the discussion outlines the semantics in terms of the internal storage, external storage, and flow of control in a conceptual PL/I machine. Every statement and type of object in the language is given a place in this scheme. [ABSTRACT FROM AUTHOR]

Copyright of INFOR is the property of Taylor & Francis Ltd and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

The article presents the author's comments on the paper entitled "The Devil is in the Detail: Hints for Practical Optimisation." According to the author, the econometric programming languages cited by the authors of the paper will usually provide reliable default settings for the user-supplied information required by a minimisation routine. He points out that this paper does a good work of explaining how to utilize a nonlinear solver.