Concurrent Tasks

One of the hardest things to do when coordinating work to be done by a team is figuring out how to express two people doing something at the same time. The Technique language grew out of a very opinionated view of how to document this.

Let's say you have a tricky problem to solve. You'll need a big computer:

life_the_universe_and_everything :

    1.  Design and build computer
    2.  Turn on the machine and assign task

Who is doing this? The esteemed engineering firm of Lunkwill and Fook, of course, representing the very best of their civilization. We don't refer to them by their individual names, though, we identify them by their role. We'll call them the @programmers .

life_the_universe_and_everything :

    1.  Design and build computer
        @programmers
            a.  Build stupendous super-computer
            b.  Install main console on executive desk in office overlooking
                the public square
    2.  Turn on the machine and assign task
        @programmers
            a.  Open briefcases and take out notebooks
            b.  Pose task

Here we've added some detail to the two steps. These are dependent substeps like you're used to but quite clearly they're scoped underneath the role, so you can now see who is performing the task.

It's a role and not a named individual because the team assigned to complete a procedure can change over time. The procedure doesn't depend on Lunkwill specifically, it depends on him / her / it as one of the team who programmed the machine.

What happens when we have more than one role involved? Steps happen sequentially, but within a step, tasks can happen concurrently:

    3.  Clarify parameters of desired calculation
        @programmers
            a.  Explain that a simple answer is desired
        @philosophers
            a.  Argue that the search for truth is the inalienable prerogative
                of working thinkers
            b.  Demand machine be turned off
        @second_greatest_computer
            a.  Assess difficulty of the problem
            b.  Commit circuits to calculation
            c.  Wait impatiently for the others to stop arguing
            d.  Explain alternative

In step 3 we have programmers, philosophers, and the computer all doing tasks at the same time. You'll note that 3/@second_greatest_computer/a can't begin until the computer knows what the task is from 2/@programmers/b, which is why these needed to be separate steps.

Once the philosophers and the programmers accede to the computer's suggestion, all the substeps in 3 are complete. The two roles can then head off together to live a lifestyle beyond their wildest dreams:

    4.  Generate publicity for the whole area of philosophy in general
        @programmers + @philosophers
            a.  Get clever agents
            b.  Disagree violently with each other in public about what Answer
                the computer is going to come up with
            c.  Profit

The procedure can now continue.

Other roles can enter the game:

    5.  Calculate the Answer to Life, The Universe, and Everything. This step
        is anticipated to take seven and a half million years
        @second_greatest_computer
            a.  Compute result
            b.  Check result very carefully
    6.  Unveil the Answer
        @second_greatest_computer
            a.  Explain that the Answer is not very satisfactory
            b.  Announce result
                {
                    [
                        "Life, the Universe, and Everything" = answer
                    ]
                }
    7.  Determine the Question
        @philosophers_descendants
            a.  Run away from angry mob
        @second_greatest_computer
            a.  Design a computer of infinite and subtle complexity
            b.  Name computer
            c.  Instruct descendants
    8.  Calculate the Question. This step will take 10 million years, give or
        take five minutes
        @greatest_computer_of_all_time
            a.  Compute result
        @mice
            a.  Supervise test subjects by
                -   running the wrong way in mazes,
                -   eating wrong bits of cheese,
                -   unexpectedly dropping dead.

Even where a role has a single occupant, @greatest_computer_of_all_time for example, we still use a role rather than the person or entity's name. You never know when an employee—or a planet—will need to be replaced.

Thus we have a procedure where steps are executed sequentially, but within steps we can express concurrency and thus coordinate work from different players (be they pan-dimensional beings or amazingly intelligent super-computers) as they strive together to find out what their purpose in life is and whether it really matters, cosmically speaking, whether they get up and go to work that day.