This page is the extended, narrative-technical version of the presentation of the volume Integrating Tools for Software Development (Prentice Hall, 1992). I kept the thread in which conceptual ideas and biographical context support one another, but organized the text into short sections that are easier to follow.
For documents: Scanned excerpts · Key figures · Table of contents
Looking back, writing this book was a wager — not only with the future of technology, but also with my own fate. The book was written in Romania, between 1987 and 1989, in a period in which research was isolated and access to the international community was precarious. Even so, I knew the ideas risked remaining dispersed unless I ordered them within a coherent framework: a model of the software process able to connect methods, activities, results, and tools into a single common language.
The manuscript was completed in 1989 and sent abroad through indirect channels, with the help of people who understood what it meant, in those years, to take a substantial technical work out of the country. The book started from a simple conviction: in large projects, the critical problem is not writing code, but organizing collective work — and therefore designing the process itself.
For more than two years, I worked on the volume in parallel with the INTERFORM project — our attempt to show that formalization, and then assisted automation, of software design was possible. During winter evenings, amid frequent power cuts, I wrote and designed what we would later try out in the laboratory; mornings belonged to the team and to technical decisions; holidays were for bibliography and drafting.
The acceptance of the article on INTERFORM at ICSE 9 (Monterey) was followed by an unexpected episode: a personal letter from Ed Yourdon, inviting me to expand the article into a book for the YOURDON Press series (which later became part of Prentice Hall).
In essence, the book proposed a semantic architecture of the software process: a view in which the process is not a vague succession of “phases,” but a universe with explicit entities, relationships, and rules of cooperation. To make this universe describable and, in part, executable, I built the model around a tetrad: Object – Activity – Agent – Tool. To this is added a fifth, decisive element: the technological environment, that is, the habitat in which the four entities live and cooperate.
The technological environment is described as a structured SEE (Software Engineering Environment), built from technological modules (TM): extensions of activities, with explicit roles, inputs/outputs, tools, norms, and operations. The coupling of modules may be predefined (chains) or opportunistic (dynamic, guided by objectives and risk). The result is a technological line of software production: open, yet structurable; integrated, yet adaptable.
I organized the book as an architecture in its own right: a layered structure in which the first part builds the conceptual infrastructure of process modeling, while the second part moves gradually from model to system, by describing INTERFORM from the inside.
For the full chapter list: Table of contents.
After building the language of objects (SODL), the language of activities / processes (SADL), and the operational toolkit, the book takes its critical step: it assembles everything into an executable machine. INTERFORM appears here as a complete executive system for the software process: a configurable machine that runs processes, sees objects in facets, launches tools, changes states, and manages exceptions.
This is the point at which modeling becomes machine: layered architecture, internal languages, tool libraries, and a central concept of state that controls what is permitted, visible, and active at each moment of work.
See also: Key figures (diagrams about states, tools, and networks) and Scanned excerpts.
In 1992, the proofreading had been completed and the discussions about the cover and editorial details followed. The book appeared in 1992 and was reissued in 1993. Sales, however, were minimal (mostly to libraries), which was a disappointment for me. I had expected a different kind of reception, perhaps even contradictory discussions. I later understood that, in the Western publishing ecosystem, the author was expected to do a large part of the promotion personally — a practice I did not know in Romania and for which I had neither the time nor the network required at that moment.
Looking back, publication in the series associated with YOURDON Press may seem surprising: at that time the series was evolving from structured methodology toward the object-oriented paradigm. I did not explicitly adopt OOP notations; the direction of the book is design — the layer above programming — and it aims at the integration of activities, coherent representations of design results, assisted automation, and integrated environment architectures.
Today, rereading these pages, I do not consider them obsolete. On the contrary: I see in them a rigor and a clarity that are often missing from recent technical texts. In the end, the book remains a plea for depth: to understand before building, to model before implementing.
For an extended presentation in document form, see Documents associated with the volume.