Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10 5/3/83; site omsvax.UUCP
Path: utzoo!linus!decvax!harpo!seismo!hao!hplabs!intelca!omsvax!puck
From: puck@omsvax.UUCP (Jerry Wheeler)
Newsgroups: net.jokes
Subject: OPCODES revisited
Message-ID: <807@omsvax.UUCP>
Date: Fri, 10-Feb-84 19:28:56 EST
Article-I.D.: omsvax.807
Posted: Fri Feb 10 19:28:56 1984
Date-Received: Wed, 15-Feb-84 05:49:03 EST
Organization: Intel Corp, Hillsboro, OR
Lines: 238

< Wombat snack >

	The OPCODE discussion that has lately (re)emerged on the net
(particularly the reference to DWIM - Do What I Mean) reminded me of
a discussion that went on a couple of years ago through our mail system
shortly after we got our VAX.  I dug out a copy of it for your amusement.
The names and other incriminating information have been removed, but some
of the former Intel employees that participated will probably recognize it.
It started out with a simple request regarding the game of 'go', and
degenerated from there.

Each separate submission is preceeded by a '>>' mark to help keep the
players apart.  Enjoy.

------------------------------------------------------------------------

>>		      -GO-

	Is there anyone who knows how to play the game of go?  Do you
know anyone who does?  Please mail me, or just come talk, if you are
interested in the game.

>> YES I know how!  I used to play very often.  I have two go sets, one
of which is very nice.  I also have two books on GO.  One is a Xerox
copy of an excellent book!

>> I have a nice 30 story, 1 bedroom apartment you both could GO to...

>> I thought "GO"to was an illegal construct???

>> GOto is not illegal, it is only unorthodox.

>> Well, GOto should be considered harmful in any case.  Anyone ever try
a "comefrom"?

>> I haven't yet tried a "comefrom", but chickens have been working with
"comefirst" for years, and some chicks have specialized in "comequick".
For the latter construct, I understand that NE Union Ave is the place
to study, as it were.

>> GOto is not illegal, but as any Turing machine proves, it is not
necessary for programming.

>> I suppose one would have to GO to a Turing machine to prove that.

>> I'd take a GOto any day over having to program a Turing machine.
(Let's see you write an ADA compiler with a Turing machine.)

>> I'd like to see a turing machine programmed to write an ADA compiler,
that would be something like a roomful of monkeys and typewriters
recreating the library of Congress.

>> Let's see anyone write an ADA compiler on anything!!!  Besides,
GO() is dead!

>> GO() is indeed dead (ie, (go lab) as in Lisp?)  That was the starting
point of the lecture:  GOto is illegal.

>> Does that make GO() immoral.

>> That just makes GO() immortal (as soon as it's illegal, all the
idiots in the world want to use it.)

>> If GO() is immortal and GO() is dead then we have (by confusion)
produced the ADA compiler via mail, as ADA is:

	illegal
	immortal
	ill defined
	and back in committee(s).

AND the compiler, when invoked, takes a "tur" or makes little "tur"'s.

QED (Quarks Emitting Dust or some such stuff).

>> I still think ADA is immoral.

>> Remember that ADA spelled backwards is hardly worth the effort.

>> Yes, but backwards spelled ADA is still backwards.  I knew a girl
named ADA once, she was indeed immoral, so that proves that GO() is
dead.

>> If GO(), then there must be an argument for it.  This makes me wonder
if the next generation languages will have a construct, GO FOR (IT).
This in turn might imply a function, GOFFER(), which would retrieve
anything requested.

>> Now, GOFFER() might evolve into G.OFFER() which suggests a good
offer.  You interviewing?

>> Mail your favorite syntactical construct (semantics optional) to
this address.  If a suitable set evolves, we might try developing a
compiler for it.  If not, the entire set of submissions will be sent
to ANSI for standardization.

>> My choice:

/* below is the special ADA construct compiler code */

GO()
{
	token	ADA;
	ADA ^= ADA;
}

>> My choice:

DO(WHAT I MEANT); NOT DO(WHAT I SAID)

>> 		DWIM();

That can put us all out of business.

>> The true semantics of DWIM are:
	DO WHAT I MEAN, NOT WHAT MY MANAGER IS EXPECTING.
This perpetuates your job as interpreter between your software and
your boss.

>> 	DWIM:

Would that resolve into two subclasses,

Do What I Really Mean

and

Do What You Think I Mean

or would that be a (non)functional parameter.

>> DWIRM() vs DWYTIM() becomes an interesting philosophical discussion.
For example, it introduces DWYTIRM().

>> Proposed for 1984 version:  DWIBFM(), Do What Is Best For Me.

>> We already have a version of DWIBFM(), with the error state:

	Or I'll Hold up Your Paycheck.

>> Of course for completely secure and correct programming we need the
omniscient version: DWIRND, that is to say, DO WHAT I REALLY NEED DONE.
The necessity for this construct is shown by the recognition that a
programmer, however competent, may not know what his program should
really be doing to solve his problem.  It will be seen that the DWIRND
construct is identically GO(d).

References:
1. Handbook of Alchemy & Metaphysics, Rubber Company, Youngstown,
Ohio.
2. "PROPHET: A Computer Language with Extended Lookahead" Ezekial,
Jeremiah, et al.
3. "DJINN: A Very Powerful Computer Language with Finicky Syntax and
No Error-Checking"  Babba, A., and forty others.

>> Of course, one has to be careful not to implement DWIW (do what I
want) instead of DWIRND.  Rudyard Kipling wrote about the DWIW construct
in his tale "The Monkey's Paw"

>> Please do not confuse

	DWIB (DO WHAT IS BEST),
	DWIR (DO WHAT IS RIGHT),
    and DWIN (DO WHAT I NEED)

with DWIRND.  It is obvious that all of these primitives fall into a
new class we can call DO().  By corollary that would be the opposite
of GO().

>> Another useful construct is DO)(, which you will note has only output
parameters, as distinguished from DO(), which has only input parameters.
This generated the DW construct (do whatever) which can be coded as 

REPEAT;
	DO)(;
NEVER END;

This procedure can be said to be always doing IT, whatever IT may be.

>> Correction:
DW:
REPEAT;
	DO(DO)();
NEVER END;

>> The only repeat-never end structure I've seen is

REPEAT;
	TAXES
	DEATH
NEVER END;

This requires the declaration

CONST	CHANGE;

>> I would suggest that the constant be named CREDIT, these days.

>> By the way that structure would be:

REPEAT;
	TAXES
UNTIL DEATH;

>> NO!!  The IRS is very good at collecting taxes after you die, too.
Your version does not cover all cases.  And if there is re-incarnation,
then my construction is the only one that covers all cases.  And
Napoleon's sister ranked both death and taxes as eternals.

>> I am greatly encouraged by the current responses to my request for
suggestions for a new language.  Therefore I am formally forming this
committee, and calling for nominations for the chair, and vice chair.
The secretary will be the VAX.  Meeting will be held online.  Those
interested in active membership should mail their interest to me.
Pending election of officers, I shall act for the chair pro-tem.  The
first order of business, is to select a name for our language.  Based
upon the preliminary comments, (see mail), I would suggest something
on the order of RELIGION, or FAITH.  However PRAYER must be avoided if
this language is ever to be acceptable in schools.

>> I would like to join the committee. My entry suggestion is a
derivation on the previous DO() set, which you have all overlooked.
It is based upon the fact that computers do whatever they want anyways,
as evidenced by the operation of iRMX 86, so the coverall instruction
would be

	DWYW(),

for Do Whatever You Want, it accepts no arguments and returns no
values. It will be most used in those cases where the programmer is
either stumped or thinks he is done.

------------------------------------------------------------------------


... you've got to ask yourself, "Do I feel lucky?".

...!{ ogcvax | microso | icalqa | intelca }!omsvax!puck