technique/examples/prototype/SystemsEngineeringProcess.tq at main · technique-lang/technique · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
% technique v1
! MIT; © 2018 Roy Kalawsky and Andrew Cowie

systems_engineering_process :

I. Define Goals and Objectives

establish_product_concept : () -> Concept

    1.  Establish Product Concept

II. Requirements Definition and Architecture

requirements_and_architecture : Concept -> Requirements, Architecture

    2.  Define Requirements <define_requirements>(concept)
    3.  Determine Architecture <determine_architecture>(concept)

define_requirements : Concept -> Requirements

determine_architecture : Concept -> Architecture

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>

build_software : Design -> Component

# Software Development

    1.  Define Interfaces and Types
        @programmers
            a.  <define_interfaces> ~ types
    2.  Write Program code
        @programmers
            a.  <writing_code>(design, types) ~ component
    3.  Unit Testing
        @programmers
            a.  <unit_tests>(component)

define_interfaces : Design -> Interfaces

writing_code : Design, Interfaces -> Component

unit_tests : Component -> Component

local_experiments : Component -> Component

# Local Testing and Experimentation

    7.  Local Testing

integration_testing : Design, Component -> SubSystem

# System Verification

    8.  Integration Testing

IV. System Validation

functional_testing : [SubSystem] -> System

    9.  Functional Testing

validate_system : Requirements, System -> Product

    10. Agree requirements have been met
        @leadership
            -   <acceptance_decision>(requirements, system) ~ product
    11. Product Launch
        @marketing + @sales
            -   <product_release>(product)

acceptance_decision : Requirements, System -> Product

product_release : Product -> Product

V. Production

operations : Product -> Product

    12. Ongoing Operations
        @operators + @users + @management

changes_upgrades : Product, ChangeRequest -> Product

    13. Changes and Upgrades
        @management
            a.  Identify new requirements
        @engineering
            b.  Assess impact on system architecture
            c.  Create a design for the both
                -   the change, and
                -   the resultant changed component
            d.  Implement the change
            e.  Test the updated component
            f.  Re-integrate System
        @management
            g.  Validate its functionality ~ product2
        @leadership
            h.  Release the updated system <operations>(product2)

VI. Retirement or Replacement

decommissioning : System -> ()

    14. Decommission System