A model of program product design
The 4th Conference on Control Systems and Computer Science (SAII-4), 17–20 June 1981, vol. III, pp. 290–295
This communication is the first publication that appeared after the defense of my doctoral thesis and one of the works in which the idea began to take explicit shape that program design should not be seen as inspired improvisation, but as a methodical activity based on intermediate forms, refinement rules, and the preservation of global behavior. In its short form, the paper concentrates the theme of the first chapter of the thesis and announces the direction that would later lead to the interform and to CAD systems for program development.
Article sheet
Bibliographic landmarks
Author: Luca-Dan Șerbănați
Title: A model of program product design
Event: The 4th Conference on Control Systems and Computer Science (SAII-4)
Date: 17–20 June 1981
Volume: vol. III
Pages: 290–295
Publisher: Publishing House / Printing Office of the Polytechnic Institute of Bucharest
Affiliation: Department of Computers, Polytechnic Institute of Bucharest
Local PDF: assets/un-model-al-proiectarii-produselor-program-1981.pdf
Facsimile of the article
Thumbnails (click to enlarge)
Fig. 1. Opening of the article: the abstract and the introduction on method, design, and programming.
Fig. 2. The formal core of the paper: the abstract machine, global behavior, and relations between abstract machines.
Fig. 3. The model of methodological norms, the conclusions, and the explicit reference to the 1980 doctoral thesis.
Significance
- the first communication published after the defense of the doctoral thesis;
- the first synthetic formulation of design modeling through intermediate forms;
- introduces the abstract machine as a methodological instrument for describing the software product;
- explicitly separates the world of the project from the rules of design;
- formalizes the two axes of refinement: functional and structural;
- represents a point of departure for the interform, for software CAD, and for the 1992 book.
Context and stakes
After completing the work on my doctoral thesis, I felt the need to synthesize in an article its most general part: the attempt to describe formally the process of program design. In the thesis, the model was still connected to a broader application, namely the implementation of a language for an interactive data-processing system. In this communication, it is detached from that context and presented as a construction with a more general methodological vocation.
The text was born in the climate of what was then called the “software crisis”: the lack of a unitary methodological basis, the difficulty of controlling complexity, and the feeling that design cannot be reduced either to code writing or to disparate heuristics. Hence the stakes of the article: the formulation of a minimal axiomatics of software design, in which both the objects acted upon by the designer and the norms by which he advances from specification to design can be described.
From this point of view, the article is not merely a technical note, but the beginning of a broader orientation. It marks the transition from an interest in compilers and languages to a concern with engineering modeling of the software product and with the formal control of the design process.
Structure and main ideas
1. Method, design, programming
The article begins with a methodological discussion. A method is defined, from a praxiological perspective, as a systematic procedure applied by an acting agent to a universe of objects, according to rules of conduct and with the purpose of achieving a goal. From this definition derive two components of any method: the universe of objects and the transformation rules applied to it.
Applied to program design, this idea leads to an image in which design is an iterative process made up of successive descriptions that become increasingly precise. An essential point is the preservation of the “history” of design: each intermediate form matters not only as an isolated state, but as a moment in a controlled becoming.
2. The abstract machine and the intermediate form
The formal core of the paper is introduced in the section on the model of intermediate forms. A processing activity is viewed, at the level of specification, through the pair ⟨D, K⟩, where D is the domain of definition and K the functional input–output relation. To describe the stages between this specification and the final design, the article proposes as its basic form the abstract machine M = ⟨Q, F, Q0⟩, where Q is the set of states, F the set of operators, and Q0 the set of initial states.
Each operator corresponds to a partial function over states, and sequences of operators define the global behavior of the machine. In this way, the article introduces a model abstract enough to describe the software product before implementation, yet rigorous enough to allow controlled comparisons and refinements.
3. Morphisms between abstract machines
Between intermediate forms, the paper does not postulate simple intuitive resemblances, but precise relations expressed by morphisms. It distinguishes three types of relations. First, the behavioral morphism, which expresses the strict preservation of behavior and may be interpreted as a simulation. Then the functional morphism, which corresponds to the detailing of operators. Finally, the structural morphism, which concerns the detailing of data and the structural decomposition of states.
This separation of refinement into two axes — functional and structural — is one of the clearest methodological gains of the article. It shows that design does not advance chaotically, but through two families of decisions that must remain compatible and preserve the desired global behavior.
4. The abstract machine with program
A further step consists in moving from the abstract machine to the abstract machine with program, that is, to the pair ⟨M, p⟩, where p is a family of sequences of operators. Thus the designed product is no longer seen only as a structure of states and operations, but also as programmed behavior, which allows the definition of the program domain and of its input–output relation.
In this framework, simulation relations are also transferred to concrete designs, and the article already suggests the idea that a valid design sequence must be composed of steps that preserve the global behavior of the processing activity.
5. Norms as rules of conduct
The last section is perhaps the most original at the methodological level. Here, the norms of a design method are treated as relations defined on the set of intermediate forms. A formal methodological framework 𝒞 = ⟨𝒥, 𝒩⟩ is thus introduced, and a method appears as a structure comprising the set of specifications, the universe of intermediate forms, the system of norms, and the set of final designs.
Design therefore becomes a sequence of intermediate forms connected by norms. In the particular case of program design, the article restricts these norms to combinations of functional and structural refinement, requiring every design step to preserve global behavior. This is the criterion of local correctness proposed by the paper.
Notable contributions
- explicitly separates the ontology of the project from the epistemology of the method: intermediate forms versus norms;
- proposes the abstract machine as a formal model of the future software product, not only of its execution;
- formalizes refinement through morphisms and simulations, avoiding ad-hoc transformations;
- introduces the idea of a central invariant of design: the preservation of global behavior;
- shows that the detailing of operators and the detailing of data must be treated separately, but within a common framework;
- connects these ideas to categories, graphs, and functors, in an early and remarkably dense formulation for the Romanian context of the time.
Seen retrospectively, the paper fixes in concentrated form the scheme that would return in many of my later contributions: a project universe, a family of intermediate descriptions, a system of norms, and two major axes of refinement. It may rightly be regarded as one of the key works in the conceptual legacy of the interform.
Why it remains relevant
Beyond its historical interest, the article remains relevant through the way it thinks design as refinement with guarantees. The idea that each transformation must preserve global behavior anticipates, in its own form, themes that later became important: behavioral contracts, correct model transformations, semantic refactorings, or families of abstract models of the ASM type.
Equally current is the separation between functional refinement and structural refinement. In many modern practices, this distinction reappears under other names, but the 1981 article already formulates it clearly and integrates it into a unified methodological framework. For this reason, it deserves to be read not only as a document of a biographical stage, but also as a text that preserves genuine conceptual value.
Facsimile
Below I keep the same convention used on the other article pages: thumbnails in the upper sheet and large plates in this section.





