On: raising the semantic level of a program

dwight dkelvey at hotmail.com
Sat Jun 27 09:49:17 CDT 2020

Hi Stan
 It sounds a little like the way most good Forth programmers deal with problems. Forth is all about semantics. Every thing is a word. The complexity of the program is left to the low level stuff. When the program is done, it isn't a program written in Forth, it is a program written in the application. At the highest levels one should not see the language it was written in one should only see the application. Well written Forth at the upper levels has only : and ; of the language showing through. The rest are just the words in a sentence like structure telling what the application is doing.
It is too bad that people insist on using languages that even at the highest level is still just a program in that particular language. All the boiler plate is still in the way of the program.
Although, taking a little more time to get used to, Lisp is something like that as well. At least well written Lisp is. One can see what the intent is at the higher levels of coding. It is just learning to read the sentences. The lower level language part is how you move the bits and bytes around. The application should tell you what it does and why. Comments should only be needed at the more confusing lower levels. At the higher levels comments would and should be redundant. The words should tell you what is being done.

From: cctalk <cctalk-bounces at classiccmp.org> on behalf of Stan Sieler via cctalk <cctalk at classiccmp.org>
Sent: Thursday, June 25, 2020 3:14 PM
To: General Discussion: On-Topic and Off-Topic Posts <cctalk at classiccmp.org>
Subject: On: raising the semantic level of a program


Not hardware ... but an antique software / programming concept.

Some decades ago (circa late 1970s?), I *think* I came across a concept of
"raising the semantic level" of a program by using defines/macros and newly
written library functions.  The concept was that a given language provided
a particular level of semantics.  By judicious/clever use of things like
macros, one could "raise" the level of semantics, effectively appearing to
add new features to the language (or, in this case, the instance of the
language as used in the program).

I *thought* I got that concept from Terry Wingrad's excellent "Breaking the
Complexity Barrier again" (Nov, 1974,
https://dl.acm.org/doi/10.1145/951761.951764 )
...but, no.  It's not in that paper.

Does the concept ring a bell?

Can anyone provide a pointer to where I might have seen it?

It's formed the basis of my own personal programming philosophy for nearly
50 years, and I want to know where I found it, or if I might have thought
of it myself.



More information about the cctalk mailing list