This chapter is the “fertile anomaly” of the thesis: using the experience of designing a compiler, I moved toward a general vision of software development. It opens the thesis by proposing a paradigm shift: it starts from the observation — recurrent in those years — that, because of the complexity of software, which often exceeds the limits of human understanding, program production had to become the object of a genuine engineering discipline. In this effort, the existence of engineering methods within the body of computer science was absolutely necessary.
Starting from the experience of developing the conversational ALGOL-60 compiler, the thesis proposes a method for designing complex program systems centered on the concept of the abstract machine (AM) — a mathematical model taken from automata theory [AM = (Q, Σ, Q₀)] — which, through successive refinements constrained by behavioral or structural relations between machines, gradually approaches the final product. The chapter formalizes the relations between AMs (homomorphisms, evolutions), programs, and realizations, offering a framework required for verification and optimization.
The proposed method requires the designer to describe processing activities through abstract machines (models close to computer architectures and programming languages), to refine interfaces, and to preserve as much as possible the “horizontal structure” (modular structure) along the “vertical structure” (the design stages leading to implementation). According to this method, design can be seen as a vertical hierarchy (levels of abstraction) of networks of AMs (horizontal modules), harmonizing the synchronic with the diachronic, the abstract with the concrete — from specification to implementation. The method can become a rigorous, modular, verifiable process, thereby anticipating Model-Driven Development.
The summary below condenses the contributions of Chapters II–VII (SICAL) and positions Chapter I as the methodological foundation. For full technical details see the extended synthesis (PDF).
Formalization of the interactive session (line-by-line dialogue), file structure (ALGOL-60 source, LIN, versioned symbol tables), command protocol (EDIT, LIST, RUN, SAVE), and the pedagogy of sub-second feedback. Functional and performance requirements are established for the multi-console environment.
Decomposition into processes (DEFJOB, JOB, instances per console), integration with SIRIS-2, static sharing of memory (read-only mapped LALR tables), and coordination of incremental compilation with real-time response.
ALGOL-60 grammar adapted for line-level analysis, LALR(1) table generator, syntax-directed translations using attribute grammars (L-type) toward LIN intermediate code; resulting in IF₁: decorated tree + partial LIN.
Static semantic restrictions, IF-II structure (FSII, FTSII, FTNII), “dirty propagation” on the dependency graph after each edit; incremental evaluation with cost proportional to the modified area.
Definition of the LIN intermediate language, operational effects on stack and heap, LIN block cache and local reallocations after recompilation; TCE translator toward CALI for real executables.
Assembly residents for console multiplexing, memory limits (~64 KB), response times: <200 ms (1 console), ~550 ms (3), <1 s (6) for 200–300 lines — demonstrating that incrementality and multi-user operation can coexist on modest hardware.
Chapter I proposes the modeling of design through abstract machines and intermediate forms, while Chapters II–VII show its realization in a complete conversational system. This bridge from theory to system later underpinned INTERFORM (1985–1989): formally orchestrated, with data, activities, tools, and states that “speak the same language”.
The complete text of the chapter is available in a clean digital edition in Romanian and English. I also provide an extended description (12 pages), which presents the structure, ideas, and contributions to software engineering, as well as a scanned copy of the chapter.
