How
to Dramatically Increase Your Programming Capability, Productivity, and Value…
in
any Corporate Programming Language
By
Paul H. Harkins
I
have been paid to program in many corporate programming languages over the last
45 years. I have also been a successful corporate programmer, programming
consultant, software company developer and owner, author of several major
corporate application software products, and a software productivity tool
patented inventor.
My
website www.harkinsaudit.com article
“Examples of 22 Corporate Programming
Languages, from the 1950s to Today” illustrates many of the major corporate
programming languages in use during my corporate programming career.
Programmers writing in virtually all of these corporate programming languages
can benefit greatly when they fully audit the source statements and variables
(data) in real-time as they execute.
Full Electronic Program Auditing
Auditing
of all of the executable source statements as they execute, together with all
of the variables (data), and the moment in time as statement executes in
real-time to a printer audit or a disk audit file can be considered “Full
Electronic Program Auditing”. This complete audit report, or journal, or disk log
is a complete recording, like a security camera video recording of the complete
history of exactly what happened during program execution of that specific job.
Like
a security video recording, the Audit Report, journal, or disk log of the
complete results of the program execution may be reviewed later to determine
exactly what and when exactly happened, and that totally eliminates the need to
attempt to reconstruct what happened exactly (an impossibility), and eliminates
the need and desirability of all guesswork about what might or could have
happened. The audit output may be converted to a fully searchable PDF file or
other file to provide powerful search and analysis capability
This
article illustrates exactly how this real-time source program and variable
auditing of ALL of the executing source statements in a
program can be easily implemented manually in any program by the person writing
the source program using the existing
source language capability, and without purchasing any additional
software or hardware.
Auditing
of all of the executing program statements is far beyond the traditional disk
journaling of before and after images of disk operands such as READ, WRITE,
UPDATE, DELETE. Full program auditing
includes all initiation executable statements from the moment of program
initiation through program completion, including passed parameter contents and
operations such as MULTIPLY, ADD, etc.
The need for Full Electronic Program Auditing
Chapter
12 “Mission Impossible” of my book
“How to Become a Highly Paid Corporate Programmer” documents the immense value
of auditing ALL of the executing source statements and variables (data) and the
moment of statement execution in real-time to an audit report, log, or journal.
This chapter also illustrates typical huge savings to the company that full
program auditing makes possible, and makes easy. There is simply no substitute
to knowing exactly what happened in the execution of all of every program’s
execution, and the data values or contents, and the moment of program
execution. That is a programmer’s (and management’s) dream which has now come
true, and can come true for you and for your company…right now, by implementing
full program auditing.
Chapter
16 “Master Millions of Lines of Complex
Code” of my book “How to Become a Highly Paid Corporate Programmer”
illustrates how full program auditing greatly simplifies and enhances corporate
programming in virtually every important phase of actual corporate programming.
Chapter
1 “How Much are You Worth?” of my
book “How to Become a Highly Paid Corporate Programmer” emphasizes and
illustrates that “Everything is Economic”.
Only
the economic (as in dollar) value that you produce or are perceived to produce
is important to the success of your programming career and to your company, not
what corporate languages or computers you use, or whether you are a coder Geek
or not, or your formal education.
The
“Real-Time Program Audit (RTPA) for RPG
Users Manual”, available for free at my website www.harkinsaudit.com, provides many
detailed and comprehensive examples of Electronic program audit output as
produced by my patented (U.S. Patent No. 6,775,827) auditing
software for the RPG programming language. Clicking on the Patent Number will
display the Patent at the Patent Office, and provide you with an idea how
automated electronic Program auditing may be accomplished in virtually any
corporate programming language.
Manual electronic
program auditing is where the programmer manually inserts the source statements
needed to fully audit the executing program statements and variables (data
contents) into a source program rather than having an software program such as
RTPA for RPG insert the audit statements into a COPY of the original source
program.
This article will
illustrate exactly how to manually insert manual electronic program audit
statements into several source RPG programs. Basic program auditing techniques
are initially presented, followed by more comprehensive programming auditing
techniques.
Implementing even basic
program auditing in source programs, such as auditing the program initiation
and completion, and perhaps disk, display and printer operations and data, is a
tremendous and immediate benefit for all corporate programming. This can be
followed with more and more auditing of key program statements, like program
CALLs, until EVERY executable source statement is audited together with the
variable (data contents) and the moment in time of each statement
execution.
The
“Real-Time Program Audit (RTPA) for RPG Users
Manual”, available for free at my website www.harkinsaudit.com, provides many
detailed and comprehensive examples of automated Full Electronic program auditing.
It provides a good basis for understanding how manual program auditing may be
easily and successfully accomplished, and vividly illustrates the value and
power of full electronic program auditing.
Full
electronic Programming Auditing means having much smarter programs, a video
recording of exactly what happened inside the computer in real-time, and the
total elimination of reconstruction attempts and guesswork as to what executed
and what happened in corporate computing.
Full
Electronic Program Auditing greatly simplifies the technical skills now needed
(like guessing) and vividly shows exactly what happened and why. This will
(already is) change the skills and talents needed for successful corporate
programming towards more business orientation skills and aptitude from
technical coding skills and aptitude.
The
time for implementation of full Electronic Program Auditing is now. Computers
are a billion times faster now than when I started in corporate programming
with IBM, and computers will get another billion times faster (and dramatically
cheaper) in the working career of programmers starting today. That means full
Electronic Program Auditing is essentially free.
Programmers
and companies that utilize full Electronic Program Auditing do and will have
huge competitive advantages (Everything is economic) over those who do not.
My
Bold Prediction about Corporate Programming
Full
Electronic Program Auditing, meaning fully auditing and recording every program
statement, variables (data content), moment of execution time, and relationship
with other executing programs, will soon become pervasive and required in virtually all of corporate programming.
The complete audit log of all program statements and data executed will become
as valuable as a security video camera tape is today, in recording, reviewing
and analyzing computer software activity at the source statement execution
level.
Examples of manually audited source programs to an output audit log
This article illustrates how the programmer can insert
audit source program statements manually into the source program to provide
full auditing of the source multiply source statement and the contents of the
variables (Hours, Rate, and Gross) and the exact time the statement was
executed.
All other executable source statements may be
similarly manually audited by the programmer.
The first examples of manual program auditing only illustrate
auditing the executing source statement and the contents of the statement
variables. The auditing of the statement
execution time, compile statement number, and do level is illustrated later in
this article.
The
first examples are from my article “Examples
of 22 Corporate Programming Languages, from the 1950s to Today”
The multiply example is a payroll calculation of
rate times hours to compute gross.
RATE
is a 5 position field with 2 decimals, with a value of 41.25.
HOURS
is a 5 position field with 2 decimals, with a value of 39.75.
GROSS
is a 5 position field with 2 decimals.
------------------------------------------------------------------------------------------------------------
On
a calculator:
Press
the Clear key
Enter
41.25 (HOURS)
Press
the X (times) key
Enter
39.75 (RATE)
Press
the = (equals) key
The
displayed product (GROSS) is 1639.6875
Round
GROSS to 1639.69 (2 decimals)
0001.00 H
0002.00 * RPGIII MULTIPLY
WITH HALF-ADJUST
0003.00 C
Z-ADD41.25 HOURS 52
0004.00 C
Z-ADD39.75 RATE 52
0005.00 C HOURS MULT
RATE GROSS 72H
The Multiply statement line 5.00 is underlined. The H means half-adjust GROSS from 1639.6875 to 2 decimals or 1639.69. This is a complete RPGIII source program.
The
computer computes GROSS as each statement is executed as in the following
program audit output:
Audit Output of RPGIII Source Program execution
Job: 025165 User/Prof: PHH
CMPLLST#
Source Statements and Variable Values
41.25
0004 C
Z-ADD39.75 RATE 52
39.75
0005
C HOURS
MULT RATE GROSS 72H
41.25 39.75
1639.69
0006 C
MOVEL'1' *INLR
1
0001.00
h
0002.00 * RPGIV multiply with half-adjust (multiply is an Eval Op code)
0003.00 d hours S 5
2
0006.00
c eval hours = 41.25
0007.00
c eval rate = 39.75
0008.00
c eval(h) gross = hours * rate
0009.00
c eval *inlr = '1'
The
multiply statement line is an eval (evaluate) operation code with the multiply
an *, and is underlined. The (h) means half-adjust gross from 1639.6875 to 2
decimals or 1639.69. This is a complete RPGIV source program.
The
computer computes gross as each statement is executed as in the following
program audit output:
Audit Output of RPGIV Fixed Format Source Program
execution
Job:
025217 User/Prof: PHH
PHH
CMPLLST#
SOU
RCE
STATEMENTS AND VARIABLE VALUES
7 c eval hours = 41.25
41.25
8 c eval rate = 39.75
39.75
1639.69 41.25
39.75
1
------------------------------------------------------------------------------------------------------------
(Note – Each source statement
ends in a semi-colon)
0001.00
h
0002.00 * RPGIV multiply with half-adjust in
free-form
0003.00
d hours S 5
2
0004.00
d rate S 5
2
0005.00
d gross S 7
2
0006.00 /free
0007.00 eval
hours = 41.25;
0008.00 eval rate = 39.75;
0009.00 eval(h)
gross = hours * rate;
0010.00 eval *inlr = '1';
0011.00 /end-free
The
multiply statement line is an eval (evaluate) operation code with the multiply
an *, and is underlined. The (h) means half-adjust gross from 1639.6875 to 2
decimals or 1639.69. This is a complete RPGIV source program.
The
computer computes gross as each statement is executed as in the following
program audit output:
Audit Output of RPGIV Free Format Source Program
execution
Program:
TESTMULTF RPGIV Multiply Free-form
Job: 025217 User/Prof:
PHH PHH
CMPLLST#
SOURCE STATEMENTS AND VARIABLE VALUES
7
eval hours = 41.25;
41.25
8
eval rate = 39.75;
39.75
9
eval(h) gross = hours *
rate;
1639.69 41.25
39.75
1
How to manually insert audit statements into RPGIV Fixed format source
program TESTMULT
This
article illustrates using a new printer file in the source program to log or
record the audited source statements and the contents of the variables in
statement (the data). This printer file is named AUDITP with a length of 198
characters per line, and is a File Definition statement. A disk file could have
been used as the audit file if desired.
fAUDITP O
F 198 PRINTER OFLIND(*INOG)
In
this basic auditing technique illustration, the programmer audits the multiply
(Eval) source statement after it
executes (so the results of the multiply are in the statement, by inserting
the following audit statements.
The
calculation statement EXCEPT AUD001 audits the execution of the
Multiply statement to the printer file AUDITP. This could also be a WRITE
statement to audit to a disk audit file.
AUD001
is the printer file definition of the multiply statement and it’s variables.
c EXCEPT AUD001
The
printer file audit statements actually log the execution of the multiply (Eval)
statement and it’s variables to the audit file.
The
Audit output file statements for the multiply (Eval) statement are:
0012.00 o* Audit source
statement
0012.01 oAUDITP
0013.00 o 26
' 9 c ‘
0014.00 o 52 'Eval(h)
gross = hours * ‘
0015.00 o 56
'rate'
0015.01 o* Audit source
statement variables
0016.00 o
0017.00 o gross L
042
0018.00 o hours L
050
0019.00 o rate L
057
---------------------------------------------------------------------------------------------------------------------
Audit
Output to printer AUDITP is:
Display Spooled
File
File .
. . . . : AUDITP Page/Line 1/1
Control . . . . .
Columns 1 - 78
Find .
. . . . .
*...+....1....+....2....+....3....+....4....+....5....+....6....+....7.
9 c Eval(h) gross = hours * rate
1639.69 41.25
39.75
The
source program with the manually inserted audit statements in bold to audit the
Multiply (Eval statement and it’s three variables is:
*************** Beginning of data
*************************************
0001.00
h
0001.01 f* Audit output printer
file
0002.01 fAUDITP O
F 198 PRINTER OFLIND(*INOE)
0003.00 * RPGIV multiply with half-adjust
0004.00 d
hours S 5
2
0005.00 d
rate S 5
2
0006.00 d
gross S 7
2
0007.00
c eval hours = 41.25
0008.00
c eval rate = 39.75
0009.00
c eval(h) gross = hours * rate
0010.00 c EXCEPT AUD001
0011.00 c eval *inlr = '1'
0012.00 o*
Audit source statement
0012.01
oAUDITP
0013.00
o 26 ' 9 c
0014.00
o
52 'Eval(h) gross = hours
0008.00
c eval rate = 39.75
0009.00
c eval(h) gross = hours * rate
0010.00
c EXCEPT AUD001
0011.00
c eval *inlr = '1'
0012.00 o* Audit source
statement
0012.01 oAUDITP
0013.00 o 26
' 9 c ‘
0014.00 o 52 'Eval(h)
gross = hours * ‘
0015.00 o 56
'rate'
0015.01 o* Audit source
statement variables
0016.00 o
0017.00 o gross L
042
0018.00 o hours L
050
0019.00 o rate L
057
****************** End of data
****************************************
Adding more audit output information to this basic
audit output
Several
very important additional audit information may be easily added to this basic
audit output, as is illustrated in the RTPA User Manual audit output examples,
including:
·
Time of execution of the executed statement, to the
millisecond.
.
·
Compile Listing statement number (including expanded
copy book statements)
·
Source Statement number from the input source member,
and copybook member
·
Program Do level (nesting level) from the compile
listing
·
Auditing of all inserted copybook statements and
embedded SQL statements
·
Auditing of program initiation and completion
information, including parameters passed among programs
·
Auditing of called programs including parameters
passed
·
Searching the electronic program audit output with
PDF.
More Electronic Program Auditing information
Please
visit www.harkinsaudit.com