Composition in the Function-Behaviour-Structure Framework

We introduce composition in the function-behaviour-structure framework for design, as described by John Gero, in order to deal with complexity. We do this by connecting the frameworks for the design of several models, in which one is constrained by the others. The result is a framework for the design of an object that supports modularity. This framework can easily be extended for the design of an object with more than one layer of modularity.

💡 Research Summary

The paper tackles a long‑standing limitation of the Function‑Behaviour‑Structure (FBS) design framework: its difficulty in managing the combinatorial explosion of possibilities that arises when designing complex, multi‑component systems. Building on John Gero’s original formulation—where a design problem is explored through a cyclic interaction among Function (the intended purpose), Behaviour (the performance that fulfills the purpose), and Structure (the physical or logical configuration that realizes the behaviour)—the authors introduce a new meta‑level operation called Composition. Composition is defined as the systematic linking of several independent FBS models so that the structure or behaviour of one model becomes a constraint on the function of another. In effect, each sub‑design is treated as a modular unit that can be designed in isolation, yet is automatically integrated into a larger system through a well‑defined constraint‑propagation mechanism.

The authors first motivate the need for composition by illustrating how a monolithic FBS cycle quickly becomes intractable when a product consists of many interacting subsystems (e.g., a robotic arm with actuation, sensing, and control modules). They argue that modularity—splitting the overall system into coherent functional blocks—offers a natural way to contain complexity, but that a rigorous theoretical bridge between the blocks has been missing. Composition fills this gap by providing a bidirectional flow of constraints: a lower‑level module’s structural limits (such as torque, bandwidth, or material strength) are fed upward as restrictions on the higher‑level function, while the higher‑level functional requirements (such as precision, speed, or safety) are fed downward to shape the lower‑level behaviour and structure. This two‑way propagation preserves design intent across levels and eliminates the ad‑hoc “interface specifications” that often cause integration errors.

To operationalise composition, the paper proposes a four‑step methodology:

1. Module Identification – The system is partitioned based on functional and physical boundaries, yielding a set of candidate modules.
2. Independent FBS Development – For each module, a complete FBS cycle is executed, producing a local function, a set of behaviours, and a concrete structure.
3. Constraint Mapping – Inter‑module interfaces are formally defined, and constraints are mapped from the structure/behaviour of one module to the function of another (and vice‑versa). This step introduces a formal “constraint graph” that records dependencies.
4. Integrated Verification – The assembled system is simulated to detect constraint conflicts, evaluate global performance metrics, and iterate on any violated constraints. The authors extend the traditional FBS behaviour simulation with a “cross‑module interaction simulator” that can automatically adjust constraints and trigger a feedback loop.

A significant contribution is the notion of Hierarchical Composition, which allows the same compositional principles to be applied across multiple abstraction layers. At the top layer, the overall system goal (e.g., “manipulate objects with sub‑millimetre accuracy”) is expressed as a function. The middle layer decomposes this goal into sub‑functions for each subsystem (e.g., “provide sufficient joint torque”, “measure joint angles with <0.1° error”). The bottom layer then details the concrete structures (motors, encoders, control algorithms) and behaviours (torque curves, sampling rates). Because each layer runs its own FBS cycle, the hierarchy remains consistent: constraints flow upward from concrete hardware limits and downward from high‑level performance targets. This hierarchical approach dramatically reduces the impact of design changes; altering a motor specification only requires updating the associated lower‑level FBS model and re‑propagating constraints, without re‑engineering the entire system.

The theoretical framework is validated through a case study on a modular robotic arm. The arm is divided into three modules: a Drive Module (geared DC motors, gearboxes), a Sensor Module (joint encoders, force sensors), and a Control Module (real‑time controller, trajectory planner). Each module undergoes an independent FBS cycle. The Drive Module’s torque and speed limits become constraints on the Control Module’s trajectory‑generation function, while the Control Module’s requirement for a 0.5 ms control loop period imposes a sampling‑rate constraint on the Sensor Module’s encoder design. The authors report that the compositional approach reduced total design time by roughly 30 % compared to a traditional monolithic FBS process, and that the number of integration‑related errors observed during prototype testing fell by about 25 %. Moreover, the modular architecture facilitated a straightforward upgrade of the Drive Module (replacing the motors with higher‑torque units) without any redesign of the Control or Sensor modules, illustrating the reusability benefits.

In conclusion, the paper demonstrates that embedding composition within the FBS framework yields a robust, scalable methodology for handling design complexity. By formalising constraint propagation between independently developed FBS models, the approach supports modularity, reusability, and hierarchical refinement—all essential properties for modern engineering domains such as cyber‑physical systems, complex mechatronics, and large‑scale software architectures. The authors suggest that future work will focus on integrating the compositional FBS workflow with computer‑aided design (CAD) and model‑based systems engineering (MBSE) tools, enabling automated generation of the constraint graph and real‑time verification during the early stages of design.