Temporal Engineering™
(4 MIN)
#VSMTemporalEngineering #temporal #engineering #software #architecture #quality

Top-Down Temporal Engineering

Gordon Morrison
Gordon Morrison

This series is a top-down overview of Temporal Engineering starting with the logic.

1) The analysis of a proposed project allows a subject matter expert (SME) to create a domain specific language (DSL) in their respective expertise language. Our current and initial educational materials all focus on the five-function calculator.

(If you are one of those that think the five-function calculator is a simple problem we challenge you to write your own using C++ or Delphi that meets our specifications. These specifications include: Add, subtract, multiply, divide, and percent. A trace for every decision made, and trace that can be turned on/off with a button. Documented code written to be judged clean, readable, and understandable by peers.)

Our first step is analyzing the 5-function calculator in a temporal manner. To accomplish this, we (the calculator SME’s) think about the order of the logical steps needed for a calculation.

Initially we are trying to capture the essence of the project and not trying to be formal in our DSL structure. The sequence is calculator = first operand number, the operation to be performed, the second operand number, and finally the result. This structure has been called Arithmetic Operating System (AOS), there are other names and approaches to calculators.

Reducing the wordiness of that sequence to Calc = Oper1 Oper8 Oper2 Result; begins to look like something that can be parsed by a computer program. The current sequence lacks details that need to be provided by the SME. In Temporal Engineering we call this first sequence the names of the Rules to be created.

The first Rule is Oper1. This is the sequence that allows the computer to create the first operand number. For simplicity we are using a number with up to four parts. So, our number consists of an optional sign, one or more digits, optionally followed by a decimal point, and that is followed by an optional fractional part consisting of zero or more digits.

The first rule now looks like this Oper1 = sign digit dot digit. This is complete except for the paperwork necessary, that being clear in case we need to totally start over and clear entry if we want to just replace the number.

The first Rule continued now looks like Oper1 = negate digit dot digit clear clear_entry; The underscore is to keep the computer happy.

Computers work on control-flow or process-flow. The hardware has a Program Counter (PC) to help guide the sequencing of instructions. Software doesn't have any time orientation. Temporal Engineering added time to software. We have a sequence without time so we will now add the time.

The optional sign true or false goes next to the digit. The digit on true stays with the digit to build a bigger number. The digit on false goes next to the optional decimal point. If the decimal point is true the next step is the fractional digit if its false then to the clear. The fractional digit if true remains with the digit building a larger fraction on number until the user enters a non-digit operation like clear or clear entry or an operator.

The Temporal Engineering sequence is complete for the first Rule Oper1 and it looks like this:

Oper1 = Negate[1,1] Digit[1,2] Dot[3,4] Digit[3,4] Clr[[0,5] ClrEnt[0,Oper8];

time->            0                1             2              3             4              5

We have a GUI application that takes care of all of this Temporal Engineering so this is just to provide a better educational understanding. Dtangle is the application part of the suite of tools we use to create Temporal Engineering logic graphically.

When you examine the DSL folder from the website download this is what you will find. The Rule Oper8 = Add Sub Mul Div; The Oper2 Rule is the same as the Oper1 Rule with minor administrative additions. And finally the Rule Result = Percent Equals Chain;

All of the Rules require sequenced time. When you examine the source code and follow the execution this process will begin to make sense.