Encapsulating non-determinacy in an abstract data type with determinate semantics

1991 ◽  
Vol 1 (1) ◽  
pp. 3-20 ◽  
Author(s):  
F. Warren Burton

AbstractA parallel program may be indeterminate so that it can adapt its behavior to the number of processors available.Indeterminate programs are hard to write, understand, modify or verify. They are impossible to debug, since they may not behave the same from one run to the next.We propose a new construct, a polymorphic abstract data type called an improving value, with operations that have indeterminate behavior but simple determinate semantics. These operations allow the type of indeterminate behavior required by many parallel algorithms.We define improving values in the context of a functional programming language, but the technique can be used in procedural programs as well.

1989 ◽  
Vol 24 (9) ◽  
pp. 152-157 ◽  
Author(s):  
J. D. Ramsdell

2002 ◽  
Author(s):  
Ch. Ykman-Couvreur ◽  
J. Lambrecht ◽  
A. van der Togt ◽  
F. Catthoor

2007 ◽  
Vol 17 (1) ◽  
pp. 131-143 ◽  
Author(s):  
DAVID WAKELING

AbstractThe functional programming community has shown some interest in spreadsheets, but surprisingly no one seems to have considered making a standard spreadsheet, such as Excel, work with a standard functional programming language, such as Haskell. In this paper, we show one way that this can be done. Our hope is that by doing so, we might get spreadsheet programmers to give functional programming a try.


2008 ◽  
Vol 16 (4) ◽  
pp. 329-339 ◽  
Author(s):  
Damian W.I. Rouson

This article approaches scientific software architecture from three analytical paths. Each path examines discrete time advancement of multiphysics phenomena governed by coupled differential equations. The new object-oriented Fortran 2003 constructs provide a formal syntax for an abstract data type (ADT) calculus. The first analysis uses traditional object-oriented software design metrics to demonstrate the high cohesion and low coupling associated with the calculus. A second analysis from the viewpoint of computational complexity theory demonstrates that a more representative bug search strategy than that considered by Rouson et al. (ACM Trans. Math. Soft.34(1) (2008)) reduces the number of lines searched in a code with λ total lines from O(λ2) to O(λ log2λ ), which in turn becomes nearly independent of the overall code size in the context of ADT calculus. The third analysis derives from information theory an argument that ADT calculus simplifies developer communications in part by minimizing the growth in interface information content as developers add new physics to a multiphysics package.


Author(s):  
Juan Guti´errez-C´ardenas ◽  
Hernan Quintana-Cruz ◽  
Diego Mego-Fernandez ◽  
Serguei Diaz-Baskakov

Sign in / Sign up

Export Citation Format

Share Document