Procedural Programming: It’s Back? It Never Went Away

Procedural Programming
It's Back? It Never Went Away
@KevlinHenney

This is the Unix philosophy:
Write programs that do one
thing and do it well.Write
programs to work together.
Doug McIlroy

In McIlroy's summary, the hard
part is his second sentence:
Write programs to work
together.
John D Cook

In the long run every
program becomes rococo
— then rubble.
Alan Perlis

I began to use the term “software
engineering” to distinguish it from
hardware and other kinds of engineering;
yet, treat each type of engineering as part of
the overall systems engineering process.
Margaret Hamilton

Define a subset of the system which is
small enough to bring to an operational
state [...] then build on that subsystem.
E E David

This strategy requires that the system
be designed in modules which can be
realized, tested, and modified
independently, apart from conventions
for intermodule communication.
E E David

The design process
is an iterative one.
Andy Kinslow

There are two classes of system designers.
The first, if given five problems will solve
them one at a time.
Andy Kinslow

The second will come back and announce
that these aren’t the real problems, and
will eventually propose a solution to the
single problem which underlies the
original five.
Andy Kinslow

This is the ‘system type’ who is great
during the initial stages of a design project.
However, you had better get rid of him
after the first six months if you want to get
a working system.
Andy Kinslow

A software system can best be
designed if the testing is interlaced
with the designing instead of
being used after the design.
Alan Perlis

proc is leap year = (int year) bool:
skip;

false;
[] proposition leap year spec =
(
("Years not divisible by 4 are not leap years",
void: (assert (not is leap year (1967))))
);

mode proposition = struct (string name, proc void test);

false;
(
);
test (leap year spec)

mode proposition = struct (string name, proc void test);
proc test = ([] proposition spec) void:
for entry from lwb spec to upb spec
do
print (name of spec [entry]);
test of spec [entry];
print (new line)
od;

year mod 4 = 0;
(
void: (assert (not is leap year (1967)))),
("Years divisible by 4 but not by 100 are leap years",
void: (assert (is leap year (1968))))
);

year mod 4 = 0 and year mod 100 /= 0;
(
void: (assert (is leap year (1968)))),
("Years divisible by 100 but not by 400 are not leap years",
);

year mod 4 = 0 and year mod 100 /= 0 or year mod 400 = 0;
(
void: (assert (is leap year (1968)))),
("Years divisible by 400 are leap years",
void: (assert (is leap year (2000))))
);

year mod 4 = 0 and year mod 100 /= 0 or year mod 400 = 0;
(
with (2018, 2001, 1967, 1), expect (false)),
with (2016, 1984, 1968, 4), expect (true)),
with (2100, 1900, 100), expect (false)),
("Years divisible by 400 are leap years",
with (2000, 1600, 400), expect (true))
);
test (is leap year, leap year spec)

mode expect = bool;
mode with = flex [1:0] int;
mode proposition = struct (string name, with inputs, expect result);

proc test = (proc (int) bool function, [] proposition spec) void:
do
string report := "", separator := " failed for ";
[] int inputs = inputs of spec [entry];
for value from lwb inputs to upb inputs
do
if
bool expected = result of spec [entry];
function (inputs [value]) /= expected
then
report +:= separator + whole(inputs[value], 0);
separator := " "
fi
od;
print (if report = "" then (new line) else (new line, report, new line) fi)
od;

proc test = (proc (int) bool function, [] proposition spec) void:
do
string report := "", separator := " failed for ";
[] int inputs = inputs of spec [entry];
for value from lwb inputs to upb inputs
do
if
bool expected = result of spec [entry];
function (inputs [value]) /= expected
then
report +:= separator + whole(inputs[value], 0);
separator := " "
fi
od;
print ((report = "" | (new line) | (new line, report, new line)))
od;

We instituted a rigorous regression
test for all of the features of AWK.
Any of the three of us who put in a
new feature into the language [...],
first had to write a test for the new
feature.
Alfred Aho
http://www.computerworld.com.au/article/216844/a-z_programming_languages_awk/

There is no such question as testing things after the
fact with simulation models, but that in effect the
testing and the replacement of simulations with
modules that are deeper and more detailed goes on
with the simulation model controlling, as it were,
the place and order in which these things are done.
Alan Perlis

As design work progresses this
simulation will gradually evolve
into the real system.
The simulation is the design.
Tad B Pinkerton

snowclone, noun
▪ clichéd wording used as a template, typically
originating in a single quote
▪ e.g., "X considered harmful", "These aren't
the Xs you're looking for", "X is the new Y",
"It's X, but not as we know it", "No X left
behind", "It's Xs all the way down", "All your
X are belong to us"

FUNCTION ISLEAP(YEAR)
LOGICAL ISLEAP
INTEGER YEAR
IF (MOD(YEAR, 400) .EQ. 0) GOTO 20
10 ISLEAP = .FALSE.
RETURN
20 ISLEAP = .TRUE.
END

LOGICAL ISLEAP
INTEGER YEAR
10 ISLEAP = .FALSE.
RETURN
20 ISLEAP = .TRUE.
RETURN
END

LOGICAL ISLEAP
INTEGER YEAR
10 ISLEAP = .FALSE.
GOTO 30
20 ISLEAP = .TRUE.
30 RETURN
END

LOGICAL ISLEAP
INTEGER YEAR
10 ISLEAP = .FALSE.
GOTO 30
20 ISLEAP = .TRUE.
GOTO 30
30 RETURN
END

LOGICAL ISLEAP
INTEGER YEAR
10 ISLEAP = .FALSE.
GOTO 30
20 ISLEAP = .TRUE.
GOTO 30
30 CONTINUE
RETURN
END

FUNCTION ISLEAP(Year)
LOGICAL ISLEAP
INTEGER YEAR
IF (MOD(YEAR, 400) .EQ. 0) THEN
ISLEAP = .TRUE.
ELSE IF (MOD(YEAR, 100) .EQ. 0) THEN
ISLEAP = .FALSE.
ELSE IF (MOD(YEAR, 4) .EQ. 0) THEN
ISLEAP = .TRUE.
ELSE
ISLEAP = .FALSE.
END IF
END

A goto completely
invalidates the high-level
structure of the code.
Taligent's Guide to Designing Programs

send(to, from, count)
register short *to, *from;
register count;
{
register n=(count+7)/8;
switch(count%8){
case 0: do{ *to = *from++;
case 7: *to = *from++;
}while(--n>0);
}
}

register count;
{
switch(count%8){
}while(--n>0);
}
}
I feel a combination of
pride and revulsion at
this discovery.
Tom Duff

register count;
{
switch(count%8){
}while(--n>0);
}
}
Many people have said that the worst
feature of C is that switches don't break
automatically before each case label.
This code forms some sort of argument
in that debate, but I'm not sure whether
it's for or against.
Tom Duff

One of the most powerful
mechanisms for program
structuring [...] is the block
and procedure concept.
Ole-Johan Dahl and C A R Hoare
"Hierarchical Program Structures"

Main Program and Subroutine
The goal is to decompose a program into
smaller pieces to help achieve modifiability.
A program is decomposed hierarchically.
Len Bass, Paul Clements & Rick Kazman
Software Architecture in Practice

afferent branch transform branch efferent branch
main
subroutine subroutine
subroutine
subroutine
subroutine
subroutine
subroutine
subroutine

There is typically a single thread of control
and each component in the hierarchy gets
this control (optionally along with some
data) from its parent and passes it along
to its children.
Len Bass, Paul Clements & Rick Kazman
Software Architecture in Practice

main
procedure procedure
procedure
procedure
procedure
procedure
procedure
procedure

main
function function
function
function
function
function
function
function

Procedural Programming: It’s Back? It Never Went Away

Procedural Programming: It’s Back? It Never Went Away

More Related Content

What's hot

Similar to Procedural Programming: It’s Back? It Never Went Away

More from Kevlin Henney

Recently uploaded

Procedural Programming: It’s Back? It Never Went Away