SCOUG-Programming Mailing List Archives

Date:	Thu, 25 Oct 2007 06:45:53 -0700
From:	"Lynn H. Maxson" <lmaxson@pacbell.net >
Reply-To:	scoug-programming@scoug.com
To:	"SCOUG Programming SIG" <scoug-programming@scoug.com >
Subject:	SCOUG-Programming: The Silver Bullet--Part 2

Content Type: text/plain

"...So we know at least one stage, the first one of
Specification, requires people intervention to resolve
ambiguities of input requirements. So we have two connected
descriptive writings involving people. The question remains do
we need more?"

Actually we should pose the question as, "Do we need more
new ones?". In truth one of the two we already have as a
"must" regardless, our "native" language. We have then only
one "new" language to learn, a specification language. Do we
need more?

Do we need another for analysis, yet another for design, and
still another for contruction? We do currently. In fact with
the advent of object-oriented programming both analysis and
design, covered by CASE tools, jumped from two used in
structured analysis and design to 16 in UML (Unified Modelling
Language).

The best answer to this question lies in our choice of
language generation, whether to remain in third generation
like C++ and JAVA, in which the stages of analysis, design,
and construction remain as separate, sequential, people-based
processes each with it own source(s), or to move to some
fourth-generation language like SQL, in which these three
stages occur as software-based processes.

In short do we remain in a generation in which we have as
many as 17 different sources to develop, maintain, and
synchronize or do we go to one with zero? Somehow I found
the answer to this a no-brainer: go with a fourth generation
language. Take advantage of the fact that every
programming language is a specification language. Choose to
use your specification language as your programming
language.

That gives you a single specification/programming language
like those of SQL, Prolog, Trilogy, and every AI (Artificial
Intelligence) language including NN (Neural Networks) in which
one stage, specification, remains people-based and the three
stages of analysis, design, and construction get assigned to
software. We have only then to decide on which language to
use.

That choice appeared obvious as well. Start with the most
complete third generation programming language, PL/I, and
upgrade it (if possible) to fourth generation. Notice the use of
the term "upgrade" instead of "change". It implies you add
something to what already exists. You add while keeping
what you have. Thus PL/I remains a "proper subset" of the
"new" specification/programming (S/P) language.

Note that previous generational upgrades from actual to
symbolic assembly to third generation HLL did not carry this
backward compatibility. Each remained a separate, distinct
language. However, once at the HLL level the possibility
exists to introduce "additions" to it without losing
compatibility: you can upgrade to a fourth generation without
giving up its third generation capabilities. Thus the third
remains a proper subset of the fourth.

The upgrade from third to fourth generation adds an
enhanced "assertion" capability. The third generation relies
on the "assignment" statement, an assertion that only one
"true" result can and must occur. If it doesn't, it produces a
"severe" program error and aborts the program.

The fourth generation adds an assertion statement that
allows for zero (false or no true results, i.e. instances) or one
or more true results. In third generation languages with
embedded SQL (fourth-generation) programmers (people)
have to take this into account in their programming. That
consideration remains in fourth generation: the need to
account for zero, one or more true instances.

This zero, one or more true instances requires a new data
type, the list aggregate. Borrowed from LISP and used
throughout all fourth generation languages means adding it to
the array and structure aggregates and operations in
expressions of PL/I. Thus we have three aggregate types
(array, structure, and list) which can occur in expressions.

Now array and structure aggregates can appear as normal
operators in a assignment statement producing a single array
or structure result. They may also appear in an assertion
statement with at least one list aggregate operator in an
expression which always returns a list (aggregate) result.
Thus the type of result determines whether we have an
assignment or assertion statement.

Now we have other fourth generation additions like "rules" to
cover. We will put off our consideration of these until after
we cover testing, the fifth stage of software development.

=====================================================

To unsubscribe from this list, send an email message
to "steward@scoug.com". In the body of the message,
put the command "unsubscribe scoug-programming".

For problems, contact the list owner at
"postmaster@scoug.com".

=====================================================

Return to [ 25 | October | 2007 ]

SCOUG, Warp Expo West, and Warpfest are trademarks of the Southern California OS/2 User Group. OS/2, Workplace Shell, and IBM are registered trademarks of International Business Machines Corporation. All other trademarks remain the property of their respective owners.