Part-compilation in high-level languages

Many programming languages include the ability to divide large programs into smaller segments, which are compiled separately. When a small modification is made to a large program, then the affected segment only has to be re-compiled.This paper discusses how high-level languages like Algol 68, Algol W or Simula 67 can incorporate part-compilation in a usable, secure and efficient way.     

A half year's experience with the facit-algol 1 compiler

The Facit-Algol 1 compiler is described briefly. Restrictions compared to Algol 60 and compatibility with other compilers is mentioned. The paper then discusses the experience with the compiler in the areas of teaching, programming, punching, debugging, and program exchanging. The conclusion is that Algol has done well and represents a great step forward.     

Implementation of a low round-off summation method

The method of Linz [1] for accurate floating-point summation has been programmed in Algol 60. The accuracy obtained confirms the analysis given by Linz. However, similar accuracy may be obtained with the use of quasi-double-precision [2].     

Program control of operating systems

The traditional job control language becomes superfluous if the existing programming languages are extended slightly. Such extensions also allow drivers and operating systems to be programmed entirely in high level languages. Ultimately, we may see machine independent operating systems. A framework is presented for an extendable operating system which allows a simple, uniform implementation of these language extensions.     

Multiple inheritance in Simula-like languages

This paper examines the subclass mechanism offered in the Simula language, and discusses how the flexibility of this mechanism would be enhanced if more than one prefix were allowed for classes (multiple inheritance). A strategy is presented for implementing this with efficiency comparable to that of current Simula.     

Decision tables in Algol 60

This paper defines an extension to Algol 60, which allows the programmer to write decision tables in his Algol program. A pre-processor converts the decision tables to Algol, and its output is used as input to the ordinary Algol compiler. The generated Algol program uses a straight-forward and efficient algorithm for choosing the appropriate decision rule.     

A game semantics for disjunctive logic programming

Denotational semantics of logic programming and its extensions (by allowing negation, disjunctions, or both) have been studied thoroughly for many years. In 1998, a game semantics was given to definite logic programs by Di Cosmo, Loddo, and Nicolet, and a few years later it was extended to deal with negation by Rondogiannis and Wadge. Both approaches were proven equivalent to the traditional semantics. In this paper we define a game semantics for disjunctive logic programs and prove soundness and completeness with respect to the minimal model semantics of Minker. The overall development has been influenced by the games studied for PCF and functional programming in general, in the styles of Abramsky–Jagadeesan–Malacaria and Hyland–Ong–Nickau.     

A comparison between simula and fortran

The general purpose simulation language SIMULA is compared with the ordinary scientific programming language FORTRAN. A typical military simulation model is programmed in both SIMULA and FORTRAN.The SIMULA program is found to be 24% shorter than the FORTRAN version. The SIMULA version is also more straightforward and gives a better picture of the simulated model. On the other hand, execution time for production runs is 64% longer with SIMULA. Weighing pros and cons shows that SIMULA will be more and more profitable, with higher personnel costs and lower computer costs to be expected in the future.     

CTL AgentSpeak(L): A specification language for agent programs

This work introduces CTL AgentSpeak(L), a logic to specify and verify expected properties of rational agents implemented in the well-known agent oriented programming language AgentSpeak(L). Our approach is closely related to the BDICTL multi-modal logic, used to reason about agents in terms of their beliefs (B), desires (D), intentions (I), and the temporal logic CTL. A new interpretation for the temporal operators, grounded in the transition system induced by the operational semantics of AgentSpeak(L), is proposed. The main contribution of the approach is a better understanding of the relation between the programming language and its logical specification, enabling us to prove expected or desired properties for any agent programmed in the language, e.g., commitment strategies. The results, as well as the specification language proposed, are very useful to reconcile computational and philosophical aspects of practical reasoning, e.g., approaching single-minded commitment as a policy-based reconsideration case.     

PySP: modeling and solving stochastic programs in Python

Although stochastic programming is a powerful tool for modeling decision-making under uncertainty, various impediments have historically prevented its wide-spread use. One factor involves the ability of non-specialists to easily express stochastic programming problems as extensions of their deterministic counterparts, which are typically formulated first. A second factor relates to the difficulty of solving stochastic programming models, particularly in the mixed-integer, non-linear, and/or multi-stage cases. Intricate, configurable, and parallel decomposition strategies are frequently required to achieve tractable run-times on large-scale problems. We simultaneously address both of these factors in our PySP software package, which is part of the Coopr open-source Python repository for optimization; the latter is distributed as part of IBM’s COIN-OR repository. To formulate a stochastic program in PySP, the user specifies both the deterministic base model (supporting linear, non-linear, and mixed-integer components) and the scenario tree model (defining the problem stages and the nature of uncertain parameters) in the Pyomo open-source algebraic modeling language. Given these two models, PySP provides two paths for solution of the corresponding stochastic program. The first alternative involves passing an extensive form to a standard deterministic solver. For more complex stochastic programs, we provide an implementation of Rockafellar and Wets’ Progressive Hedging algorithm. Our particular focus is on the use of Progressive Hedging as an effective heuristic for obtaining approximate solutions to multi-stage stochastic programs. By leveraging the combination of a high-level programming language (Python) and the embedding of the base deterministic model in that language (Pyomo), we are able to provide completely generic and highly configurable solver implementations. PySP has been used by a number of research groups, including our own, to rapidly prototype and solve difficult stochastic programming problems.     

An approach to deciding the observational equivalence of Algol-like languages

We prove that the observational equivalence of third-order finitary (i.e. recursion-free) Idealized Algol (IA) is decidable using Game Semantics. By modelling the state explicitly in our games, we show that the denotation of a term M of this fragment of IA is a compactly innocent strategy-with-state, i.e. the strategy is generated by a finite view function f_M. Given any such f_M, we construct a real-time deterministic pushdown automaton (DPDA) that recognizes the complete plays of the knowing-strategy denotation of M. Since such plays characterize observational equivalence, and there is an algorithm for deciding whether any two DPDAs recognize the same language, we obtain a procedure for deciding the observational equivalence of third-order finitary IA. Restricted to second-order terms, the DPDA representation cuts down to a deterministic finite automaton; thus our approach gives a new proof of Ghica and McCusker’s regular-expression characterization for this fragment. Our algorithmic representation of program meanings, which is compositional, provides a foundation for model-checking a wide range of behavioural properties of IA and other cognate programming languages. Another result concerns second-order IA with full recursion: we show that observational equivalence for this fragment is undecidable.     

Simulation in Microcomputers Revisited

This note discusses experiences in running discrete-events simulation models on an Apple II microcomputer. The use of PASCAL as a simulation language is commented on. To give an indication of the type of simulations that can be run on a micro, a fairly complex model relating to icebreaking operations is discussed. Run times for this model are mentioned. It is indicated how those run times can be reduced by programming part of the random number generation in assembly language. The conclusion is that significant simulation work can be done on a small micro like the Apple II.     

Dynamic programming: An interactive approach

An interactive approach to the formulation, modeling, analysis, and solution of discrete deterministic dynamic programming problems is presented. The approach utilizes APL both as the mathematical and the programming language. The interactive capabilities of APL and the simple one-to-one correspondence between the programming and the mathematical language provide an extremely convenient environment for dynamic programming investigations in general and for teaching/learning purposes in particular. The approach is illustrated by a simple model and a numerical example.     

The efficient solution of large-scale linear programming problems—some algorithmic techniques and computational results

First, this paper presents the results of experiments with algorithmic techniques for efficiently solving medium and large scale linear and mixed integer programming problems. The techniques presented here are either original or recent.The solution of a great number of problems has shown that efficient problem solving requires automatic adaptation of algorithmic techniques upon problem characteristics. We show when a given technique should be used for a particular problem.The last part of this paper describes an attempt to provide a powerful mathematical programming language, allowing an easy programming of specific studies on medium-size models such as the recursive use of LP or the build-up of algorithms based on the simplex method.All these features have been implemented in the IBM Mathematical Programming System, MPSX/370, and its feature MIP/370. Extensive numerical results and comparisons on real-life problems are provided and commented upon.Presented at the IXth International Symposium on Mathematical Programming in Budapest (1976).     

Machine dependent programming in common languages

It is suggested that we should distinguish between common programming languages and common solutions to specific problems. A solution may depend on specific machine characteristics even though it is expressed in a common language. It is further suggested that in future common programming languages this should be admitted openly by allowing the programmer to get access to the machine characteristics at hand through Environment Enquiries which are part of the language. Some specific examples of Environment Enquiries are given.An earlier version of this paper was published in ALGOL BULLETIN no. 18, October 1964.     

MODLER: Modeling by object-driven linear elemental relations

This paper describes a system to represent linear programming models and their instances. In addition to a modeling language, MODLER has an extensive query capability which includes a multi-view architecture. Further, randomization options provide rapid prototyping. The MODLER system is part of a workbench for building and managing decision support systems that are based on linear programming.This research was supported by a consortium of industries: Amoco Oil Company, Shell Development Company, Chesapeake Decision Science, GAMS Development Corp., Ketron Management Science, MathPro, Inc., Optimal Methods, Inc., and XMP Software, Inc. Partial support was also provided by the Office of Naval Research (Contract No. N-00014-88-K-0104).     

A dynamic data structure suitable for adaptive mesh refinement in finite element method

This paper describes a dynamic data structure and its implementation, used for an optimum mesh generator. The implementation of this mesh generator was a part of a software package implemented to solve electromagnetic field problems using the finite element method. This mesh generator takes advantage of the Delaunay algorithm, which maximizes the summation of the smallest angles in all triangles and thus creates a mesh that is proved to be an optimum mesh for use in the finite element method. The dynamic data structure is explained and the source code is reviewed. The programs have been written in Pascal programming language.     

On a software tool for statistics with linguistic data

We present a software tool by which we can support statistical evaluations in the presence of linguistic data. We define a language for calculation and statistics on linguistic data (the command language) and an interpreter for this language. The interpreter is written in the programming language Pascal.