Larger Processes
Describing a much larger procedure in Technique
An example showing using Technique to describe a much larger procedure — in this case the entire process of doing systems engineering on a software project. This pushes the limits of what the language is for, but nevertheless illustrates that Technique can be used for very large structures as well as very detailed ones:
III. Implementation
design_and_build : Requirements -> System
# Engineering Design, Build, and Verification
4. Engineering Design <engineering_design>(requirements) ~ designs
5. Software Development
{ foreach design in designs }
a. <implement>(design) ~ component
6. Integration Testing
{ foreach (design, component) in zip(designs, components) }
a. <integration_testing>(design, component)
engineering_design : Requirements -> [Design]
# Engineering Design
Given a set of requirements the engineering profession can undertake detailed
analysis and turn the _idea_ into a technical _design_ for how the problem
will be approached and what is actually to be built.
implement : Design -> Component
# Build and Test
1. Prototypes and explorations <prototypes>(design)
2. Software Development <build_software>
3. Local Testing and Experimentation <local_experiments>
Many of the features of the Technique language are on display here. Titles, descriptions, and prose content still carry the core of the document, but now we have control structures, function calls, invocations from one procedure to another, and parameters being passed to those invocations.
The procedures in this document have signatures showing the types of values that each procedure requires and that it provides. Procedure signatures are optional, but when present help ensure the program is correctly constructed before trying to execute it.
Most of all this illustrates the composability of procedures in Technique. Small building blocks combine to make larger endeavours possible.