Results 1  10
of
12
Algorithm theories and design tactics
 Science of Computer Programming
, 1990
"... Algorithm theories represent the structure common to a class of algorithms, such as divideandconquer or backtrack. An algorithm theory for a class A provides the basis for design tactics – specialized methods for designing Aalgorithms from formal problem specifications. We illustrate this approac ..."
Abstract

Cited by 48 (15 self)
 Add to MetaCart
(Show Context)
Algorithm theories represent the structure common to a class of algorithms, such as divideandconquer or backtrack. An algorithm theory for a class A provides the basis for design tactics – specialized methods for designing Aalgorithms from formal problem specifications. We illustrate this approach with recent work on the theory of global search algorithms and briefly mention several others. Several design tactics have been implemented in the KIDS/CYPRESS system and have been used to semiautomatically derive many algorithms. 1.
Constructing Specification Morphisms
 Journal of Symbolic Computation
, 1993
"... This paper is part of a broader research program to explore a mechanizable model of software development based on algebraic specifications and specification morphisms. An algebraic specification (or simply a specification) defines a language and constrains its possible meanings via axioms and infere ..."
Abstract

Cited by 43 (7 self)
 Add to MetaCart
This paper is part of a broader research program to explore a mechanizable model of software development based on algebraic specifications and specification morphisms. An algebraic specification (or simply a specification) defines a language and constrains its possible meanings via axioms and inference rules. Specifications can be used to express many kinds of softwarerelated artifacts, including domain models (Srinivas(1991)), formal requirements (Astesiano and Wirsing (1987), Ehrig and Mahr (1990), Partsch (1990), Sannella and Tarlecki (1985)), programming languages (Broy et al. (1987), Goguen and Winkler (1988), Hoare (1989)), abstract data types (Goguen et al. (1978), Guttag and Horning (1978)), and abstract algorithms (Smith and Lowry (1990)). There has been much work on operations for constructing larger specifications from smaller specifications (Astesiano and Wirsing (1987), Burstall and Goguen (1977), Sannella and Tarlecki (1988)). A specification morphism translates the language of one specification into the language of another specification in a way that preserves theorems. Specification morphisms underlie several aspects of software development, including specification refine
Toward a Classification Approach to Design
 Proc. of AMAST'96
, 1996
"... This paper addresses the problem of how to construct refinements of specifications formally and incrementally. The key idea is to use a taxonomy of abstract design concepts, each represented by a design theory. An abstract design concept is applied by constructing a specification morphism from its d ..."
Abstract

Cited by 37 (9 self)
 Add to MetaCart
(Show Context)
This paper addresses the problem of how to construct refinements of specifications formally and incrementally. The key idea is to use a taxonomy of abstract design concepts, each represented by a design theory. An abstract design concept is applied by constructing a specification morphism from its design theory to a requirement specification. Procedures for propagating constraints, computing colimits, and constructing specification morphisms provide computational support for this approach. Although we conjecture that classification generally applies to the incremental application of knowledge represented in a taxonomy of design theories, this paper mainly focuses on algorithm design theories and presents several examples of design by classification.
Dynamic programming via static incrementalization
 In Proceedings of the 8th European Symposium on Programming
, 1999
"... Dynamic programming is an important algorithm design technique. It is used for solving problems whose solutions involve recursively solving subproblems that share subsubproblems. While a straightforward recursive program solves common subsubproblems repeatedly and often takes exponential time, a dyn ..."
Abstract

Cited by 27 (13 self)
 Add to MetaCart
(Show Context)
Dynamic programming is an important algorithm design technique. It is used for solving problems whose solutions involve recursively solving subproblems that share subsubproblems. While a straightforward recursive program solves common subsubproblems repeatedly and often takes exponential time, a dynamic programming algorithm solves every subsubproblem just once, saves the result, reuses it when the subsubproblem is encountered again, and takes polynomial time. This paper describes a systematic method for transforming programs written as straightforward recursions into programs that use dynamic programming. The method extends the original program to cache all possibly computed values, incrementalizes the extended program with respect to an input increment to use and maintain all cached results, prunes out cached results that are not used in the incremental computation, and uses the resulting incremental program to form an optimized new program. Incrementalization statically exploits semantics of both control structures and data structures and maintains as invariants equalities characterizing cached results. The principle underlying incrementalization is general for achieving drastic program speedups. Compared with previous methods that perform memoization or tabulation, the method based on incrementalization is more powerful and systematic. It has been implemented and applied to numerous problems and succeeded on all of them. 1
Mechanizing the Development of Software
 Client Resources on the Internet, IEEE Multimedia Systems ’99
, 1999
"... . This paper presents a mechanizable framework for software development by refinement. The framework is based on a category of specifications. The key idea is representing knowledge about programming concepts, such as algorithm design, datatype refinement, and expression simplification, by means of ..."
Abstract

Cited by 20 (8 self)
 Add to MetaCart
. This paper presents a mechanizable framework for software development by refinement. The framework is based on a category of specifications. The key idea is representing knowledge about programming concepts, such as algorithm design, datatype refinement, and expression simplification, by means of taxonomies of specifications and morphisms. Examples are drawn from working systems Specware, Designware, and Planware. Contents 1. Overview 3 2. Basic Concepts 4 2.1. Specifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2. Morphisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3. The Category of Specs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.4. Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.4.1. The Structuring of Specifications . . . . . . . . . . . . . . . . . . 8 2.4.2. Refinement and Diagrams . . . . . . . . . . . . . . . . . . . . . . 9 2.5. Logic Morphisms and Code ...
Diagrams for Software Synthesis
 Proceedings of the 8 th KnowledgeBased Software Engineering Conference
, 1993
"... We describe the formal environment at Kestrel for synthesizing programs. We show that straightforward formalization, persistently applied at all levels of system description and system derivation, produces a scalable architecture for a synthesis environment. The primitive building blocks of our fram ..."
Abstract

Cited by 17 (0 self)
 Add to MetaCart
(Show Context)
We describe the formal environment at Kestrel for synthesizing programs. We show that straightforward formalization, persistently applied at all levels of system description and system derivation, produces a scalable architecture for a synthesis environment. The primitive building blocks of our framework are specifications, which encapsulate types and operations, and specification arrows, which are relations between specifications. The design of a system is represented as a diagram of specifications and arrows. Synthesis steps manipulate such diagrams, for example, by adding design detail to some specification, or by building new diagrams. A design history is a diagram of diagrams. Thus, we have a formal, knowledgebased, and machinesupported counterpart to such software engineering methodologies as CASE and OOP. 1 Introduction At the heart of the software problem lies the lack of adequate means to express and manage (1) clear, wellstructured problem specifications, (2) efficient sof...
A Generic Program for Sequential Decision Processes
 Programming Languages: Implementations, Logics, and Programs
, 1995
"... This paper is an attempt to persuade you of my viewpoint by presenting a novel generic program for a certain class of optimisation problems, named sequential decision processes. This class was originally identified by Richard Bellman in his pioneering work on dynamic programming [4]. It is a perfect ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
(Show Context)
This paper is an attempt to persuade you of my viewpoint by presenting a novel generic program for a certain class of optimisation problems, named sequential decision processes. This class was originally identified by Richard Bellman in his pioneering work on dynamic programming [4]. It is a perfect example of a class of problems which are very much alike, but which has until now escaped solution by a single program. Those readers who have followed some of the work that Richard Bird and I have been doing over the last five years [6, 7] will recognise many individual examples: all of these have now been unified. The point of this observation is that even when you are on the lookout for generic programs, it can take a rather long time to discover them. The presentation below will follow that earlier work, by referring to the calculus of relations and the relational theory of data types. I shall however attempt to be light on the formalism, as I do not regard it as essential to the main thesis of this paper. Undoubtedly there are other (perhaps more convenient) notations in which the same ideas could be developed. This paper does assume some degree of familiarity with a lazy functional programming language such as Haskell, Hope, Miranda
Program synthesis
 Automated Deduction  A Basis for Applications
, 1998
"... Since almost 30 years software production has to face two major problems: the cost of nonstandard software, caused by long development times and the constant need for maintenance, and a lack of confidence in the reliability of software. Recent accidents like the crash of KAL’s 747 in August 1997 or ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
(Show Context)
Since almost 30 years software production has to face two major problems: the cost of nonstandard software, caused by long development times and the constant need for maintenance, and a lack of confidence in the reliability of software. Recent accidents like the crash of KAL’s 747 in August 1997 or the
Program Optimization Using Indexed and Recursive Data Structures
, 2002
"... This paper describes a systematic method for optimizing recursive functions using both indexed and recursive data structures. The method is based on two critical ideas: first, determining a minimal input increment operation so as to compute a function on repeatedly incremented input; second, determi ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
This paper describes a systematic method for optimizing recursive functions using both indexed and recursive data structures. The method is based on two critical ideas: first, determining a minimal input increment operation so as to compute a function on repeatedly incremented input; second, determining appropriate additional values to maintain in appropriate data structures, based on what values are needed in computation on an incremented input and how these values can be established and accessed. Once these two are determined, the method extends the original program to return the additional values, derives an incremental version of the extended program, and forms an optimized program that repeatedly calls the incremental program. The method can derive all dynamic programming algorithms found in standard algorithm textbooks. There are many previous methods for deriving efficient algorithms, but none is as simple, general, and systematic as ours.
Dynamic Programming as a Software Component
 Proceedings of CSCC
"... Abstract: Dynamic programming is usually regarded as a design technique, where each application is designed as an individual program. This contrasts with other techniques such as linear programming, where there exists a single generic program that solves all instances. From a software engineering p ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
Abstract: Dynamic programming is usually regarded as a design technique, where each application is designed as an individual program. This contrasts with other techniques such as linear programming, where there exists a single generic program that solves all instances. From a software engineering perspective, the lack of a generic solution to dynamic programming is somewhat unsatisfactory. It would be much preferable if dynamic programming could be understood as a software component, where the ideas common to all its applications are explicit in shared code. In this paper, we argue that such a component does indeed exist, at least for a large class of applications in which the decision process is a sequential scan of the input sequence. We also assess the suitability of C++ for expressing this type of generic program, and argue that the simplicity offered by lazy functional programming is preferable. In particular, functional programs can be manipulated as algebraic expressions. The paper does not present any novel results: it is an introduction to recent work on the formalisation of algorithmic paradigms in software engineering. KeyWords: Dynamic programming; sequential decision process; software component; functional programming; algebra of programming; program derivation. 1