Upload
gordon-morrison
View
213
Download
0
Embed Size (px)
DESCRIPTION
Webinar given during the 2010 Delphi Code Rage 5.
Citation preview
Temporal Engineeringwith Delphi
A New Technology Changing the GameBy
Gordon Morrison, AuthorBreaking the Time Barrier
Agenda1. Open Software2. The Challenge3. Traditional Approaches4. The Bread Crumb Problem5. My Solution6. Implementation7. Quantification8. Why Time is Important9. Questions
www.vsmerlot.com2
1. Open Software• This presentation is based on technology in
my patent– I have made this patented work freely available– Anyone can use this technology, go for it!– The patent is U.S. Patent #6,345,387
• Issued Feb 2002• Download from the patent office
– This technology is described in my book• Reads easier and better than my patent• Title: Breaking the Time Barrier
www.vsmerlot.com3
www.vsmerlot.com
2. The Challenge• Using your traditional spatial If-Then-Else
(ITE) approach– Produce a five-function calculator
– add, subtract, multiply, divide, and percent• The specification is at: www.vsmerlot.com• Count the number of ITE and Case/Default
Statements– Count every logic decision point– Don’t use my temporal approach
4
The Challenge Test
• Conform to the specification• Successfully complete the test matrix• Final Test is:
– Enter ‘-3.14159 - -2.14159=‘– There are eighteen entries– How many logic test will your code make?
www.vsmerlot.com5
3. Traditional Approaches
• Using the traditional state machine– Expect ninety plus logic tests
• If – then – else• Switch – case – default • Case – value
• How well will you do?
www.vsmerlot.com6
www.vsmerlot.com
Proper State Machine(1)
• In a proper state machine, the state transitions are all complete and orthogonal.– Complete Transitions: a transition is defined for every
possible situation.– Orthogonal Transitions: none of the transitions have
overlapping conditions.
• With a proper state machine– a next state is defined for every possible condition– the designated next state is unique
• My comment:– The proper state machine is spatial using If-Then-Else (ITE)– The proper state machine doesn’t know where it’s working
(1)- © 2005 Carnegie Mellon University – PSP II Designing and Verifying State Machines- page 41
7
www.vsmerlot.com
Spatial Calculator Statechart• The author’s
implementation:– 112 ITE / Case– 1,000+ LOC
• Arrows are ambiguous– -> Transitions– -> Events– -> States
• Minus is an ambiguous transition
• Begin to negate1• subtract• opEntered to negated2
“Practical Statecharts in C/C++, © CMP Books, Miro Samek, Ph.D.8
www.vsmerlot.com
Spatial Calculator Call Diagram
• This diagram has no calls to trace display
• It’s very complex
9
www.vsmerlot.com
Spatial With Debugging
• Spatial trace– Red lines …
• Trace debug– Each function– Embedded– Side effects
10
4. The Bread Crumb Problem• Edsger Dijkstra once asked, "Why has elegance
found so little following?"• Imagine a CPU without a program counter (PC)
– The hardware would need to save states continually• Dropping bread crumbs
– After an interrupt determine where it was executing• Look for the trail of bread crumbs
– Massive amounts of logic as administrative overhead• Bread crumb support built in
– This is spatial logic
www.vsmerlot.com11
PC -> Pointer
• The program counter is a temporal pointer– Hardware is temporal (mostly)
• Spatial application software does not have an equivalent PC
• Traditional state machines were created to treat the symptom of no software PC– Solution drop bread crumbs– We call these ‘state machines’
www.vsmerlot.com12
5. My Solution
• Create an application pointer (temporal)– One ‘time pointer’ for every Engine/Table– The time pointer keeps track of application
logic– The time pointer is always available for
progressive protocol based application– The time pointer eliminates most bread
crumb logic
www.vsmerlot.com13
www.vsmerlot.com
Temporal State Machine (TSM)• Event or non-event driven applications• States are true or false
– Transitions are next true or next false
• Three fundamental parts– Engine (time, logic test, trace, and control)– Logic-Flow / Rule Table (class)– Data-Flow / Reusable Members
• Logic-flow is orthogonal to data-flow– No control flow in data manipulation– No data manipulation in control flow
14
www.vsmerlot.com
TSM Structure• Engine/Table relationship
– iTime is the pointer into array of rule/step– Table contains 1 or more rules– Each rule has a single entry point
• Rules are like basic blocks
• Array of rules consist of steps– Every step is a binary state
• Each step has a test condition• Each step has a True Behavior• Each step has a Next Rule/Step (iTime pointer)• Each step has a False Behavior • Each step has a Next Rule/Step (iTime pointer)• Each step has a Trace (tied to the specification)
15
www.vsmerlot.com
TSM Pattern
Data-Flow
…On…
…Off…
…On…
…Off…
Logic-FlowEngineT-Trace
F-Trace
temporal• iTime pointer• Dynamically
binds• Tracing
– True Trace– False Trace
16
Table
www.vsmerlot.com
Temporal vs. Spatial ITE
• Temporal domain– Time Indexed
• Reduces complexity– State diagrams– Call diagrams– Models
• Reduces code size• Increases reuse• Includes trace• Preemptable
• Spatial domain– Test bread crumbs
• Increases complexity– State diagrams– Call diagrams– Models
• Increases code size• Decreases reuse• Manual trace• ~Not Preemptable
17
www.vsmerlot.com
Engine / Table RelationshipEngine• Engine is temporal (iTime)• Preemption control (while)
– Test condition (if – state)• Dynamic bind True Behavior
– Next True Rule/Step iTime– True Trace
• Dynamic bind False Behavior– Next False Rule/Step iTime– False Trace
– End if – logic– End while – control loop
Table• Each row is a temporal
sequence– Rule/Step (name)– Test condition (state)
• True Behavior– Next True Rule/Step
• False Behavior– Next False Rule/Step
– Trace (unique to app)
18
www.vsmerlot.com
6. Implementationprocedure TCOSAFrame.Run(intState integer);beginbEngineLocal := TRUE;iState := intState;while bEngineLocal AND bEngineGlobal dobegin
if iState = rRule[iTime].iState thenbegin
rRule[iTime].pTrueRule;True_Trace(iTime);iTime := rRule[iTime].iTrueRule;
end elsebegin
rRule[iTime].pFalseRule;False_Trace(iTime);iTime := rRule[iTime].iFalseRule;
end;end;
end;
iTime is temporal
Determined by logic19
Dynamically Bind-True
Dynamically Bind-False
Delphi Structure Setup// ************** Temporal Rules Definition ******************
pProcedureType = procedure of Object; // Dynamic Bind DefinitionTCOSARules = classpublic // the logic test can also be defined as a Boolean functionprivate
iTime : integer;iState : integer; // logic test // Static State DefinitionpTrueRule : pProcedureType; // Dynamic Bind TrueiTrueRule : integer;pFalseRule : pProcedureType; // Dynamic Bind FalseiFalseRule : integer;iTrace : integer;
end;
www.vsmerlot.com20
Delphi Logic Table Setup
rRule : Array [0..24] of TCOSARules; // logic table allocation
procedure pBRT(iTime : integer; iState : integer;pTrueRule : pProcedureType; iTrueRule : integer;pFalseRule : pProcedureType; iFalseRule : integer;iTrace : integer); // prototype fill logic array
www.vsmerlot.com21
Implementation Logicprocedure TCOSAcalc.pBRT(iTime : integer; iState : integer;
pTrueRule : pProcedureType; iTrueRule : integer;pFalseRule : pProcedureType; iFalseRule : integer; iTrace : integer);
beginrRule[iTime] := TCOSARules.Create; // create rowrRule[iTime].iTime := iTime; // fill in rowrRule[iTime].iState := iState; rRule[iTime].pTrueRule := pTrueRule;rRule[iTime].iTrueRule := iTrueRule;rRule[iTime].pFalseRule := pFalseRule;rRule[iTime].iFalseRule := iFalseRule;rRule[iTime].iTrace := iTrace;
end;
www.vsmerlot.com22
Dynamic Calls Build Logic
// Next Next// Rules Static True True False False// Steps State Behavior Rule Behavior Rule TracepBRT(rOpr1, iNeg44, Negate, rOpr1+1,Clr_Buf, rOpr1+1,100);pBRT(rOpr1+1,iDigit, Any_Number,rOpr1+1,Ignore, rOpr1+2,101);pBRT(rOpr1+2,iDot59, One_Period,rOpr1+3,Ignore, rOpr1+4,102);pBRT(rOpr1+3,iDigit, Any_Number,rOpr1+3,Ignore, rOpr1+4,103);
www.vsmerlot.com23
23-Steps of Calculator Logic
www.vsmerlot.com24
www.vsmerlot.com
The User Perspective(tends to be temporal)
• Calculator– Enter Operand 1 (optional sign)– Enter Operation ( + - * / )– Enter Operand 2 (optional sign)– Select Result Type ( = % ( + - * / ))
• The user perspective is generally temporal• Let’s look at entering
– ‘-’ ‘3’ ‘.’ ‘1’ ‘4’ ‘1’ ‘5’ ‘9’– Followed by the Subtract Operation
25
Entered -
temporal
True BehaviorEntered 3
temporal
False BehaviorEntered .
temporal
Entered 1
temporal
Entered 4
temporal
Entered 1
temporal
Entered 5
temporal
Entered 9Count Step Trace Eng Static Dynamic Behavior Value 1 +T= 0; 100 Off; 44; 44; Negate; N= - 2 +T= 1; 101 Off; 1; 1; Any_Number N= -3 3 ĞF= 1; 101 On; 1; 59; Ignore; N= 4 +T= 2; 102 Off; 59; 59; One_Period; N= -3. 5 +T= 3; 103 Off; 1; 1; Any_Number N= -3.1 6 +T= 3; 103 Off; 1; 1; Any_Number N= -3.14 7 +T= 3; 103 Off; 1; 1; Any_Number N= -3.141 8 +T= 3; 103 Off; 1; 1; Any_Number N= -3.1415 9 +T= 3; 103 Off; 1; 1; Any_Number N= -3.14159
Trace
temporal
Enter Operation (‘-’)
temporal
Not a Number
temporal
Not CE or C
temporal
Not Addition
temporal
10 ĞF= 3; 103 On; 1; 44; Ignore; N= 11 ĞF= 4; 104 On; 12; 44; Ignore; N= 12 ĞF= 5; 105 On; 11; 44; Ignore; N= 13 ĞF= 6; 106 On; 1; 44; Push_Disp; N= 14 ĞF= 7; 500 On; 43; 44; Ignore; N= 15 +T= 8; 501 On; 44; 1; Subtraction; N= -3.14159
TraceMatch Subtraction
temporal
www.vsmerlot.com
Understanding the Time IndexENTER Rule State True Action Next True False Action Next False
‘-’ rOper1 = <iNeg44>? Negate rOper1+1 Ignore rOper1+1
‘3’ +1 = <iDigit>* Any_Number rOper1+1 Ignore rOper1+2
‘.’ +2 = <iDot59>? One_Period rOper1+3 Ignore rOper1+4
‘14159’ +3 = <iDigit>* Any_Number rOper1+3 Ignore rOper1+4
Time +4
39
• I know where I am• I know where I came from• I know where I am going• At iTime + 4 ‘-’ is “not a number” from iTime+3
Time
www.vsmerlot.com
7. Quantification
T TR DS Behavior Value1 100 44; Negate; N= -2 101 1; Any_Number; N= -33 101 59; Ignore; N=4 102 59; One_Period; N= -3.5 103 1; Any_Number; N= -3.16 103 1; Any_Number; N= -3.147 103 1; Any_Number; N= -3.1418 103 1; Any_Number; N= -3.14159 103 1; Any_Number; N= -3.1415910 103 44; Ignore; N=
Compare Temporal Trace
40
To Spatial Trace
www.vsmerlot.com41
T Behavior e->sig ValueO O O19, g-negated1, 2, 020, negated121, g-negated1, 1, -022, g-negated1, 1010, -0O O O31, int132, g-int1, 1, -333, g-int1, 1101, -334, g-frac1, 0, -3.O O O37, g-frac1, 2, -3.
38, frac139, g-frac1, 1, -3.40, g-frac1, 1010, -3.O O O45, g-frac1, 1107, -3.1415946, g-Oper1, 1107, -3.1415947, g-frac1, 3, -3.1415948, g-opEntered, 0, -3.1415949, g-Oper1, 0, -3.1415950, g-Oper1, 3, -3.1415951, g-opEntered, 2, -3.1415952, opEntered53, g-opEntered, 1, -3.1415954, g-opEntered, 1107, -3.14159
Temporal-Logic Counts
www.vsmerlot.com42
• -3.14159 – ten steps to enter nine actions– 90% efficient– 10% of cost is overhead
• -3.14159 - - 2.14195 = thirty steps for eighteen actions– 60% efficient– 40% of cost is overhead
Spatial-Logic Counts• -3.14159 – fifty-four steps for nine actions
– 16.67 % efficient– 83.34% of cost is overhead
• -3.14159 - - 2.14195 = ninety-six steps for eighteen actions– 18.75 % efficient– 81.25% of cost is overhead
www.vsmerlot.com43
Spatial Enter “-” OnlyTrc= 1, g-calc, sig= 0 ; Operand= , Trc= 2, g-calc, sig= 0 ; Operand= , Trc= 3, g-calc, sig= 1 ; Operand= , Trc= 4, g-clear; Operand= , Trc= 5, g-ready, sig= 0 ; Operand= 0, Trc= 6, g-ready, sig= 2 ; Operand= 0, Trc= 7, g-ready, sig= 1 ; Operand= 0, Trc= 8, g-begin, sig= 0 ; Operand= 0, Trc= 9, g-begin, sig= 2 ; Operand= 0, Trc= 10, g-begin, sig= 1 ; Operand= 0, Trc= 11, g-begin, sig= 1107 ; Operand= 0, Trc= 12, g-negated1, sig= 0 ; Operand= 0, Trc= 13, g-begin, sig= 0 ; Operand= 0, Trc= 14, g-calc, sig= 0 ; Operand= 0, Trc= 15, g-begin, sig= 3 ; Operand= 0,
www.vsmerlot.com44
Trc= 16, g-ready, sig= 3 ; Operand= 0, Trc= 17, g-ready, sig= 0 ; Operand= 0, Trc= 18, g-negated1, sig= 2 ; Operand= 0, Trc= 19, g-negated1, sig= 1 ; Operand= -0, Trc= 20, g-negated1, sig= 100 ; Operand= -0, Trc= 21, g-calc, sig= 100 ; Operand= -0, Trc= 22, g-negated1, sig= 3 ; Operand= -0, Trc= 23, g-final, sig= 0 ; Operand= -0, - End of Analysis
Trc= 24, g-calc, sig= 0 ; Operand= -0, Trc= 25, g-calc, sig= 3 ; Operand= -0, Trc= 26, g-final, sig= 2 ; Operand= -0, Trc= 27, g-final, sig= 1 ; Operand= -0, - End of Analysis
www.vsmerlot.com
A Temporal State Diagram
• Simple state view• True Behavior
– One green arrow• False Behavior
– One red arrow• Temporal
– Trace– Specification
• Compliance
45
www.vsmerlot.com
Statechart ComparisonTemporal Spatial
46
www.vsmerlot.com
Call Diagram ComplexityTemporal Spatial
47
Summary
Temporal Actions Logic Steps Efficiency Overhead‐pi 9 10 90.0% 10.0%
‐pi‐(‐pi‐1) 18 30 60.0% 40.0%
Spatial‐pi 9 54 16.67% 83.34%
‐pi‐(‐pi‐1) 18 96 18.75% 81.25%
www.vsmerlot.com48
www.vsmerlot.com
8. Why Time is Important• Understanding “Time” in software means not having to do
an “if” to test where the program is executing and what has happened.– 23 Logic points-Temporal calculator example– 112 Logic points-Spatial calculator example– Sampling of spatial logic tests
• 3 tests for IDC_PLUS• 4 tests IDC_MINUS• 2 tests IDC_MULT• 2 tests IDC_DIVIDE• 9 tests for IDC_0• 11 tests for IDC_1_9
49
Spatial Software• Must leave a trail of “bread crumb” states
– This is pure overhead• Must track down where it was
– This is pure overhead• Difficult to maintain
– Keeping the overhead straight• Difficult to modify
– Keeping the overhead straight
www.vsmerlot.com50
Temporal Software
• Keeps a temporal pointer• Reduces complexity• Eliminates much of the overhead• Easier to maintain• Easier to modify
– Add new rule– Change the logic
www.vsmerlot.com51
Software Quality
• Testing doesn’t improve quality– Testing fixes quality problems– Quality is still poor
• Temporal engineering– Improves quality– Reduces overhead logic– Fewer things to go wrong
www.vsmerlot.com52
Where I’ve Used Temporal• Disk driver analysis (Symbios Logic)• Data migration (US West / HP)• Data filtering• Lexer/Parser – Data analyzer• Radar control system• Robotic arm control• Embedded applications• Code generator
www.vsmerlot.com53
The End – Definitions• COSA – Coherent Object System Architecture
– U.S. Patent #6,345,387 abandoned by inventor– Available to the public in book: Breaking the Time Barrier– NOT associated with www.rebelscience.org
• BNF – Backus-Naur Format– Diagramming the logic of syntax– Basis for temporal engineering
• ITE – If-Then-Else logic – commonly referred to as ‘spaghetti code’
• CMU – Carnegie Mellon University• SEI – Software Engineering Institute at CMU• CPU – Central Processing Unit• UML – Unified Modeling Language
www.vsmerlot.com54