This is an engineering book. The idea of thinking like an engineer is built upon learning how an engineer thinks. 

A key excerpt from this book was computer programming. Information theory is a central theme for computer science. The idea is that there is a logical sequence in which computer programs communicate. 

What I found so compelling about this book was the parallels to programming in our industry. We have a series of variables that we need to account for: person (experience, schedule, biomechanical-physiological constraints) and environment (space, equipment, other users). From there we program a number of inputs to reach a certain destination.

Inputs we can compare to computer programs in a binary sense. For instance computer code is binary, sequences of 1’s and 0’s to create a certain output. There are a number of laws that guide this process, but one was (Huntingtons?) that equates the number of 1’s or 0’s netting n = < or > 1. This could create a certain error rate that makes the output sporadic or hard to predict. This happens a lot in strength training programs. 

There are a lot of things that are binary in a training program. Volume and intensity are one. If we have more focus on volume we lose the ability to generate higher force. If we focus on intensity we lose the ability to generate work. N in this case is off from a myopic focus on aspect leading to error message of over prioritization of a singular focus. 

A clearer example of this is distribution of push and pulls in a microcycle for structural balance. We can make this comparison to coding with programming of pull = 1 and pushes = 0. So a training program that may be written as: 

• Push (0) = Pull (1)

  • A1 Push = 0

  • A2 Pull = 1

  • B1 Push = 0

  • B2 Pull = 1

• Push (0) > Pull (1)

  • A1 Push = 0

  • B1 Pull = 1

  • B2 Push = 0

There could be a unique reason for this intention: unequal distribution of pushes and pulls. They are training for an output that is focussed on a singular aspect. This could come at the expense of noise, which in this case could increase the rate of injury. The balance of pushes and pulls is as much as removing errors, or injuries, as it is achieving higher functional levels. 

This could all be a reach in regards to comparing computer programming to programming training. However, I would argue that there has to be a logical sequence. Binary aspects of programming should be accounted for every training session. If not there is an increased potential for unpredictable outcomes. With multivariate environments with open system organisms we need constraints to assure certain aspects.