Asp Forum - The Importance of Terminology's Quality

Xah Lee

5/7/2008 11:14:00 PM

I'd like to introduce a blog post by Stephen Wolfram, on the design
process of Mathematica. In particular, he touches on the importance of
naming of functions.

• Ten Thousand Hours of Design Reviews (2008 Jan 10) by Stephen
Wolfram
http://blog.wolfram.com/2008/01/10/ten-thousand-hours-of-desig...

The issue is fitting here today, in our discussion of “closure”
terminology recently, as well the jargons “lisp 1 vs lisp2” (multi-
meaning space vs single-meaning space), “tail recursion”, “currying”,
“lambda”, that perennially crop up here and elsewhere in computer
language forums in wild misunderstanding and brouhaha.

The functions in Mathematica, are usually very well-name, in contrast
to most other computing languages. In particular, the naming in
Mathematica, as Stephen Wolfram implied in his blog above, takes the
perspective of naming by capturing the essense, or mathematical
essence, of the keyword in question. (as opposed to, naming it
according to convention, which often came from historical happenings)
When a thing is well-named from the perspective of what it actually
“mathematically” is, as opposed to historical developments, it avoids
vast amount of potential confusion.

Let me give a few example.

• “lambda”, widely used as a keyword in functional languages, is named
just “Function” in Mathematica. The “lambda” happend to be called so
in the field of symbolic logic, is due to use of the greek letter
lambda “?” by happenstance. The word does not convey what it means.
While, the name “Function”, stands for the mathematical concept of
“function” as is.

• Module, Block, in Mathematica is in lisp's various “let*”. The
lisp's keywords “let”, is based on the English word “let”. That word
is one of the English word with multitudes of meanings. If you look up
its definition in a dictionary, you'll see that it means many
disparate things. One of them, as in “let's go”, has the meaning of
“permit; to cause to; allow”. This meaning is rather vague from a
mathematical sense. Mathematica's choice of Module, Block, is based on
the idea that it builds a self-contained segment of code. (however,
the choice of Block as keyword here isn't perfect, since the word also
has meanings like “obstruct; jam”)

• Functions that takes elements out of list are variously named First,
Rest, Last, Extract, Part, Take, Select, Cases, DeleteCases... as
opposed to “car”, “cdr”, “filter”, “filter”, “pop”, “shift”,
“unshift”, in lisps and perl and other langs.

The above are some examples. The thing to note is that, Mathematica's
choices are often such that the word stands for the meaning themselves
in some logical and independent way as much as possible, without
having dependent on a particular computer science field's context or
history. One easy way to confirm this, is taking a keyword and ask a
wide audience, who doesn't know about the language or even unfamiliar
of computer programing, to guess what it means. The wide audience can
be made up of mathematicians, scientists, engineers, programers,
laymen. This general audience, are more likely to guess correctly what
Mathematica's keyword is meant in the language, than the the name used
in other computer languages who's naming choices goes by convention or
context.

(for example, Perl's naming heavily relies on unix culture (grep,
pipe, hash...), while functional lang's namings are typically heavily
based on the field of mathematical logic (e.g. lambda, currying,
closure, monad, ...). Lisp's cons, car, cdr, are based on computer
hardware (this particular naming, caused a major damage to the lisp
language to this day). (Other examples: pop, shift are based on
computer science jargon of “stack”. Grep is from Global Regular
Expression Print, while Regular Expression is from theoretical
computer science of Automata... The name regex has done major hidden
damage to the computing industry, in the sense that if it have just
called it “string patterns”, then a lot explanations, literatures,
confusions, would have been avoided.))

(Note: Keywords or functions in Mathematica are not necessarily always
best named. Nor are there always one absolute choice as best, as there
are many other considerations, such as the force of wide existing
convention, the context where the function are used, brevity,
limitations of English language, different scientific context (e.g.
math, physics, engineering), or even human preferences.)

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

Many of the issues regarding the importance and effects of
terminology's quality, i've wrote about since about 2000. Here are the
relevant essays:

• Jargons of Info Tech Industry
http://x...UnixResource_dir/writ/ja...

• The Jargon “Lisp1” vs “Lisp2”
http://x...emacs/lisp1_vs_...

• The Term Curring In Computer Science
http://x...UnixResource_dir/writ/cur...

• What Is Closure In A Programing Language
http://x...UnixResource_dir/writ/cl...

• What are OOP's Jargons and Complexities
http://x...Periodic_dosage_dir/t...

• Sun Microsystem's abuse of term “API” and “Interface”
http://x...java-a-day/inte...

• Math Terminology and Naming of Things
http://x...cmaci/notation/math_na...

Xah
xah@xahlee.org
? http://x...

?

104 Answers

Bruce C. Baker

5/7/2008 11:54:00 PM

<xahlee@gmail.com> wrote in message
news:f4abdb41-be28-4628-a2ad-7fb6cea6ed65@u12g2000prd.googlegroups.com...

[...]

(for example, Perl's naming heavily relies on unix culture (grep,
pipe, hash...), ...

"hash" + "pipe"? Ahhhhh, /no wonder/ Perl is the syntactic mishmash it is!
;-)

Kyle M

5/8/2008 2:15:00 AM

> • Module, Block, in Mathematica is in lisp's various “let*”. The
> lisp's keywords “let”, is based on the English word “let”. That word
> is one of the English word with multitudes of meanings. If you look up
> its definition in a dictionary, you'll see that it means many
> disparate things. One of them, as in “let's go”, has the meaning of
> “permit; to cause to; allow”. This meaning is rather vague from a
> mathematical sense. Mathematica's choice of Module, Block, is based on
> the idea that it builds a self-contained segment of code. (however,
> the choice of Block as keyword here isn't perfect, since the word also
> has meanings like “obstruct; jam”)

If the purpose of let is to introduce one or more variable bindings,
then I don't see how changing to block or module would improve
anything. I've always found it fairly intuitive to parse (let ((x
5)) ...) to "let x be five". Additionally, replacing let with the
synonyms you provided would approximately yield "permit x to be five"
or "allow x to be five". In my mind you have constructed an argument
in favor of let here (obviously it's better than block, because
nobody's going to come along and be confused about whether let will
"obstruct" or "jam" them :)

There are many easy targets to poke at in the CL spec. let isn't one
of those.

George Neuner

5/8/2008 5:06:00 AM

On Wed, 7 May 2008 16:13:36 -0700 (PDT), "xahlee@gmail.com"
<xahlee@gmail.com> wrote:

>I'd like to introduce a blog post by Stephen Wolfram, on the design
>process of Mathematica. In particular, he touches on the importance of
>naming of functions.
>
>? Ten Thousand Hours of Design Reviews (2008 Jan 10) by Stephen
>Wolfram
> http://blog.wolfram.com/2008/01/10/ten-thousand-hours-of-desig...
>
>The issue is fitting here today, in our discussion of ?closure?
>terminology recently, as well the jargons ?lisp 1 vs lisp2? (multi-
>meaning space vs single-meaning space), ?tail recursion?, ?currying?,
>?lambda?, that perennially crop up here and elsewhere in computer
>language forums in wild misunderstanding and brouhaha.
>
>The functions in Mathematica, are usually very well-name, in contrast
>to most other computing languages. In particular, the naming in
>Mathematica, as Stephen Wolfram implied in his blog above, takes the
>perspective of naming by capturing the essense, or mathematical
>essence, of the keyword in question. (as opposed to, naming it
>according to convention, which often came from historical happenings)
>When a thing is well-named from the perspective of what it actually
>?mathematically? is, as opposed to historical developments, it avoids
>vast amount of potential confusion.
>
>Let me give a few example.
>
>? ?lambda?, widely used as a keyword in functional languages, is named
>just ?Function? in Mathematica. The ?lambda? happend to be called so
>in the field of symbolic logic, is due to use of the greek letter
>lambda ??? by happenstance. The word does not convey what it means.
>While, the name ?Function?, stands for the mathematical concept of
>?function? as is.

Lambda is not a function - it is a function constructor. A better
name for it might be MAKE-FUNCTION.

I (and probably anyone else you might ask) will agree that the term
"lambda" is not indicative of it's meaning, but it's meaning is not
synonymous with "function" as you suggest.

I suspect Mathematica of just following historical convention itself.
Mathematica uses the term inappropriately just as it was (ab)used in
Pascal (circa 1970). I'm not aware of earlier (ab)uses but there
probably were some.

>? Module, Block, in Mathematica is in lisp's various ?let*?. The
>lisp's keywords ?let?, is based on the English word ?let?. That word
>is one of the English word with multitudes of meanings. If you look up
>its definition in a dictionary, you'll see that it means many
>disparate things. One of them, as in ?let's go?, has the meaning of
>?permit; to cause to; allow?. This meaning is rather vague from a
>mathematical sense. Mathematica's choice of Module, Block, is based on
>the idea that it builds a self-contained segment of code. (however,
>the choice of Block as keyword here isn't perfect, since the word also
>has meanings like ?obstruct; jam?)

"Let" is the preferred mathematical term for introducing a variable.
Lisp uses it in that meaning. What a word means or doesn't in English
is not particularly relevant to its use in another language. There
are many instances of two human languages using identical looking
words with very different meanings. Why should computer languages be
immune?

>? Functions that takes elements out of list are variously named First,
>Rest, Last, Extract, Part, Take, Select, Cases, DeleteCases... as
>opposed to ?car?, ?cdr?, ?filter?, ?filter?, ?pop?, ?shift?,
>?unshift?, in lisps and perl and other langs.

Lisp has "first" and "rest" - which are just synonyms for "car" and
"cdr". Older programmers typically prefer car and cdr for historical
reasons, but few object to the use of first and rest except for
semantic reasons - Lisp does not have a list data type, lists are
aggregates constructed from a primitive pair data type. Pairs can be
used to construct trees as well as lists and "rest" has little meaning
for a tree. When used with lists, first and rest are meaningful terms
and no one will object to them.

Besides which, you easily create synonyms for car and cdr (and
virtually any other Lisp function) with no more burden on the reader
of your code than using a C macro. You can call them "first and
rest", or "first and second", or "left and right", or "red and black"
or whatever else makes sense for your data.

People coming to Lisp from other languages often complain of macros
that they have to learn "a new language" every time they read a
program. But in fact, the same is true in all languages - the reader
always has to learn the user-defined functions and how they are used
to make sense of the code. In that sense Lisp is no different from
any other language.

Common Lisp doesn't have "filter". Even so, with respect to the
merits of calling a function "extract" or "select" versus "filter", I
think that's just a matter of familiarity. The term "filter" conveys
a more general idea than the others and can, by parameterization,
perform either function.

>The above are some examples. The thing to note is that, Mathematica's
>choices are often such that the word stands for the meaning themselves
>in some logical and independent way as much as possible, without
>having dependent on a particular computer science field's context or
>history. One easy way to confirm this, is taking a keyword and ask a
>wide audience, who doesn't know about the language or even unfamiliar
>of computer programing, to guess what it means. The wide audience can
>be made up of mathematicians, scientists, engineers, programers,
>laymen. This general audience, are more likely to guess correctly what
>Mathematica's keyword is meant in the language, than the the name used
>in other computer languages who's naming choices goes by convention or
>context.
>
>(for example, Perl's naming heavily relies on unix culture (grep,
>pipe, hash...), while functional lang's namings are typically heavily
>based on the field of mathematical logic (e.g. lambda, currying,
>closure, monad, ...). Lisp's cons, car, cdr, are based on computer
>hardware (this particular naming, caused a major damage to the lisp
>language to this day). (Other examples: pop, shift are based on
>computer science jargon of ?stack?. Grep is from Global Regular
>Expression Print, while Regular Expression is from theoretical
>computer science of Automata... The name regex has done major hidden
>damage to the computing industry, in the sense that if it have just
>called it ?string patterns?, then a lot explanations, literatures,
>confusions, would have been avoided.))
>
>(Note: Keywords or functions in Mathematica are not necessarily always
>best named. Nor are there always one absolute choice as best, as there
>are many other considerations, such as the force of wide existing
>convention, the context where the function are used, brevity,
>limitations of English language, different scientific context (e.g.
>math, physics, engineering), or even human preferences.)
>
>----------------------------
>
>Many of the issues regarding the importance and effects of
>terminology's quality, i've wrote about since about 2000. Here are the
>relevant essays:
>
>? Jargons of Info Tech Industry
> http://x...UnixResource_dir/writ/ja...
>
>? The Jargon ?Lisp1? vs ?Lisp2?
> http://x...emacs/lisp1_vs_...
>
>? The Term Curring In Computer Science
> http://x...UnixResource_dir/writ/cur...
>
>? What Is Closure In A Programing Language
> http://x...UnixResource_dir/writ/cl...
>
>? What are OOP's Jargons and Complexities
> http://x...Periodic_dosage_dir/t...
>
>? Sun Microsystem's abuse of term ?API? and ?Interface?
> http://x...java-a-day/inte...
>
>? Math Terminology and Naming of Things
> http://x...cmaci/notation/math_na...
>
> Xah
> xah@xahlee.org
>? http://x...
>
>?

George
--
for email reply remove "/" from address

J?rgen Exner

5/8/2008 6:05:00 AM

George Neuner <gneuner2/@/comcast.net> wrote:
>On Wed, 7 May 2008 16:13:36 -0700 (PDT), "xahlee@gmail.com"
><xahlee@gmail.com> wrote:

+-------------------+ .:\:\:/:/:.
| PLEASE DO NOT | :.:\:\:/:/:.:
| FEED THE TROLLS | :=.' - - '.=:
| | '=(\ 9 9 /)='
| Thank you, | ( (_) )
| Management | /`-vvv-' +-------------------+ / | | @@@ / /|,,,,,|\ | | @@@ /_// /^\ \\_ @x@@x@ | | |/ WW( ( ) )WW
\||||/ | | \| __\,,\ /,,/__
\||/ | | | jgs (______Y______)
/\/\/\/\/\/\/\/\//\/\\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/==============================================================

jue

John Thingstad

5/8/2008 8:06:00 AM

PÃ¥ Thu, 08 May 2008 04:14:35 +0200, skrev Kyle McGivney
<KyleMcG@gmail.com>:

>> â?¢ Module, Block, in Mathematica is in lisp's various â??let*â?. The
>> lisp's keywords â??letâ?, is based on the English word â??letâ?. That word
>> is one of the English word with multitudes of meanings. If you look up
>> its definition in a dictionary, you'll see that it means many
>> disparate things. One of them, as in â??let's goâ?, has the meaning of
>> â??permit; to cause to; allowâ?. This meaning is rather vague from a
>> mathematical sense. Mathematica's choice of Module, Block, is based on
>> the idea that it builds a self-contained segment of code. (however,
>> the choice of Block as keyword here isn't perfect, since the word also
>> has meanings like â??obstruct; jamâ?)
>
> If the purpose of let is to introduce one or more variable bindings,
> then I don't see how changing to block or module would improve
> anything. I've always found it fairly intuitive to parse (let ((x
> 5)) ...) to "let x be five". Additionally, replacing let with the
> synonyms you provided would approximately yield "permit x to be five"
> or "allow x to be five". In my mind you have constructed an argument
> in favor of let here (obviously it's better than block, because
> nobody's going to come along and be confused about whether let will
> "obstruct" or "jam" them :)

How about bind?
(bind ((v f (mod i)) ((a b) list) (t (rem q)))

1. is a multiple-value-bind
2. is a destructuring-bind
3. is a let

http://common-lisp.net/project/meta...

To me this is a example of where the ANSI group could have spent more time
on naming.

--------------
John Thingstad

kodifik

5/8/2008 8:12:00 AM

> | PLEASE DO NOT | :.:\:\:/:/:.:
> | FEED THE TROLLS | :=.' - - '.=:

I don't think Xah is trolling here (contrary to his/her habit)
but posing an interesting matter of discussion.

Don't know to which point it fits, but I would like to do some rather
novel comment on operator naming:
As a non native english speaker, the first time I ever encountered the
word "if" was when learning to program. The same can be said of the
other words (for, then, else...) This caused my brain to adscribe them
meanings completely outside the context of everyday language. My point
is that perhaps this is advantageous. So, contrary to tradition (which
considers a desirable goal to write programs as close as possible to
everyday english), I found convenient that programming languages use
words different from the words of my native tongue. I suspect that is
why car and cdr have caught on vs. first end rest.

usenet1.3.CalRobert

5/8/2008 10:26:00 AM

> From: "xah...@gmail.com" <xah...@gmail.com>
> the importance of naming of functions.

I agree, that's a useful consideration in the design of any system
based on keywords, such as names of functions or operators.
(I'm not using "keyword" in the sense of a symbol in the KEYWORD package.)

> the naming in Mathematica, as Stephen Wolfram implied in his blog
> above, takes the perspective of naming by capturing the essense, or
> mathematical essence, of the keyword in question.

For concepts adapted from mathematics, that naming meta-convention makes sense.
For concepts adapted from data-processing, it's not so clearly good.

> lambda, widely used as a keyword in functional languages, is
> named just Function in Mathematica.

That makes sense, but then what does Mathematica call the special
operator which Common Lisp calls Function? Or is that not provided,
and the programmer must case-by-case handcode what they really mean?
(function foo) == (symbol-function 'foo) ;so FUNCTION not really needed there
(function (lambda (x) (+ x y)) ;y is a lexical variable to be encapsulated
; into the resultant closure
How would you do something like that in mathematica?

> Module, Block, in Mathematica is in lisp's various let*
> The lisp's keywords let, is based on the English word let.

No, that's not correct. It's based on the mathematical use of "let":
Let R be the complete ordered field of real numbers.
Let S be the subset of R consisting of numbers which satisfy
equations expressed in transcendental functions with rational
parameters.
Prove that S is dense in R.
(Yeah, the question is trivial, but I'm just showing how "let" might be used.)

I see nothing wrong with LET used in that way in Lisp.
Bind would be good too.
I don't like Module or Block at all, because those words convey
nothing about binding some temporary local name to represent some
globally-definable concept, and they actually mis-lead because
module can mean either something like a vector space over a ring,
or a set of functions/methods that serve some small problem domain
within a larger library of functions/methods, or a set of lectures
on a single-topic within a curriculum, while Block sounds more like
just some random consecutive interval of statements rather having
nothing specific to do with bindings. TAGBODY or PROGN would be
more properly called Block perhaps.

> One easy way to confirm this, is taking a keyword and ask a wide
> audience, who doesn't know about the language or even unfamiliar of
> computer programing, to guess what it means.

That is a biassed question because the only options are the words
you choose in advance. Better would be to reverse the question: Ask
random people on the street what they would like to call these
concepts:
1 You set up a temporary relation between a name and some datum,
such that all references to that name give you that same datum.
For example you might set up the name 'n' to temporarily mean 5.
Fill in the missing word: (word (n 5) <say "ouch" n times>)
2 You set up a rule by which one step of data-processing is performed,
taking input to produce output. For example you set up a rule by
which the input value is divided by two if it's even but
multiplied by three and then 1 added if it was odd.
Fill in the missing word: (word (n) <if n even n/2 else 3*n+1>)
3 You set up a rule as above, but also give it a permanent name.
Fill in the missing word: (word collatz (n) <if n even n/2 else 3*n+1>)
4 You already have a rule that takes two input data and produces one output.
(oldword foo (x y) <absolute value of difference between x and y>)
You now know one of the two inputs, and that info won't change for a while,
and you hate to keep repeating it. So you want to define a new rule
that has that one known parameter built-in so that you only have
to say the *other* parameter each time you use the new rule.
Fill in the missing newword: (newword foo <x is fixed as 3>)
So I'd choose words: 1=let 2=lambda 3=defun 4=curry.
What words would a typical man on the street choose instead?

> The name regex has done major hidden damage to the computing industry

I have my own gripe against regular expressions ("regex" for short).
I hate the extremely terse format, with horrible concoctions of
escape and anti-escape magic characters, to fit within Unix's
255-character limit on command lines, compared to a nicely
s-expression nested notation that would be possible if regex hadn't
entrenched itself so solidly.

Lew

5/8/2008 10:52:00 AM

kodifik@eurogaran.com wrote:
>> | PLEASE DO NOT | :.:\:\:/:/:.:
>> | FEED THE TROLLS | :=.' - - '.=:
>
> I don't think Xah is trolling here (contrary to his/her habit)
> but posing an interesting matter of discussion.

Interesting is in the eye of the beholder. After you'd read the same recycled
crud from certain posters again and again, it because trollish spam.

--
Lew

Lew

5/8/2008 10:54:00 AM

Robert Maas, http://tinyur... wrote:
> I have my own gripe against regular expressions ("regex" for short).
> I hate the extremely terse format, with horrible concoctions of
> escape and anti-escape magic characters, to fit within Unix's
> 255-character limit on command lines, compared to a nicely
> s-expression nested notation that would be possible if regex hadn't
> entrenched itself so solidly.

This is all very interesting, but not Java.

--
Lew

Sherm Pendley

5/8/2008 3:09:00 PM

kodifik@eurogaran.com writes:

>> | PLEASE DO NOT | :.:\:\:/:/:.:
>> | FEED THE TROLLS | :=.' - - '.=:
>
> I don't think Xah is trolling here (contrary to his/her habit)
> but posing an interesting matter of discussion.

It might be interesting in the abstract, but any such discussion, when
cross-posted to multiple language groups on usenet, will inevitably
devolve into a flamewar as proponents of the various languages argue
about which language better expresses the ideas being talked about.
It's like a law of usenet or something.

If Xah wanted an interesting discussion, he could have posted this to
one language-neutral group such as comp.programming. He doesn't want
that - he wants the multi-group flamefest.

sherm--

--
My blog: http://shermspace.bl...
Cocoa programming in Perl: http://camelbones.sourc...

comp.lang.python

The Importance of Terminology's Quality