merits of Lisp vs Python

[Mark Tarver]

How do you compare Python to Lisp? What specific advantages do you
think that one has over the other?

Note I'm not a Python person and I have no axes to grind here. This is
just a question for my general education.

Mark

[Paul Boddie]

Willem Broekema wrote:

Paul Rubin wrote:

Does this count as a "children of a lesser Python"?

This sounds like a quite derogatory first question.

I wouldn't take it that way: it's only a quote from an opinion piece
about alternative Python implementations (albeit a contentious one).

CLPython is not a dead and abandoned project, nor is execution speed
its main goal, nor are Python semantics bended anywhere (it can run
the Pie-thon benchmark). Sure, some recently introduced language
features are missing, but with just a little effort that's solved...

What would it take to get Python people more interested in it? I've
been monitoring the site [1] and the mailing list [2] for some time,
but nothing particularly visible seems to be happening. And wouldn't a
more prominent announcement be the first step to some real publicity? I
think it only got announced on comp.lang.lisp [3] with someone picking
up on it in comp.lang.pytho n. Perhaps getting it on the python.org
front page would attract some attention, although I accept that a lot
of Python developers would rather mess around writing C than writing
Lisp.

Anyway, I'm happy to hear that you're still working on CLPython.

Paul

P.S. Follow-ups set to comp.lang.pytho n.

[1] http://trac.common-lisp.net/clpython/
[2] http://common-lisp.net/pipermail/clpython-devel/
[3] http://groups.google.com/group/comp....ae88c5f9a59143

[David Golden]

Actually, in English, "parenthesi s" means the bit in between the
brackets.

The various kinds of brackets (amongst other punctuation marks
including, in most english texts, commas) *demarcate* parentheses.

Wikipedia's "Parenthesi s (rhetoric)" is, at time of writing, the correct
British English definition, citing the OED:
http://en.wikipedia.org/wiki/Parenthesis_%28rhetoric%29

"An explanatory or qualifying word, clause, or sentence inserted into a
passage with which it has not necessarily any grammatical connection,
and from which it is usually marked off by round or square brackets,
dashes, or commas"

The use of round brackets to demarcate parentheses in america eventually
somehow led to round brackets themselves being called parentheses in
america, but that usage still makes little sense to many native
speakers of British (or Hiberno-) English outside the computing field.

It's like calling a quotation mark a "quote" instead of a "quotation
mark". And lo, guess who does that too...

Calling round brackets "parenthesi s marks" would be acceptable but
perhaps ambiguous in British English, probably needing further
qualification like "double quotation mark", "single quotation mark".

[Ken Tilton]

Ken Tilton wrote:

>

Paul Rubin wrote:

>Ken Tilton <ke*******@gmai l.comwrites:

>>Have you read On Lisp by Paul Graham? It is on-line. Just the preface
will do, I think, maybe also Chapter One where he raves on macros. Do
you think he is mistaken? Confused? Lying? Mutant?

I remember Paul Graham's piece about macros that made him sound like
someone who went nuts with them, as is certainly possible to do.

But you could have just flipped thru the rest of the pages to see if he
/had/ gone nuts with them!

> In
my experience, good coders write for clarity and that includes in
their use of Lisp macros. All in all Lisp's macro system is something
like the C preprocessor. Yes, you can obfuscate things horribly with
it, but you can also use it to make things clearer, and that's what
good programmers do.

One has to be from the US and of a certain age to remember this, but
this old line from a commercial for high-octane gasoline says it for me:
power to be used, not abused.

Here is a bit of concrete I just tossed off:

(defmacro defskill (id &body skill-info)
`(progn
,@(loop with sub-id = id
for (q . q-def) in skill-info
collecting
(ecase q
((title annotations hints)
`(defmethod ,(intern (conc$ 'skill- q)) ((tf-id (eql
',sub-id)))
,@q-def))))))

It lets me code this:

(defskill absolute-value
(title "Absolute Value")
(annotations
"Take the absolute value of #op#."
"The vertical bars around #op# mean 'the absolute value of' #op#."
"Absolute value of #strn# is the 'distance' of #strn# from zero."
"Absolute value is always zero or positive: #str|n|=n#, and
#str|-n|=n#.")
(hints
"What do those vertical bars around #op# mean?"
"Have you learned about 'absolute value'?"
"Absolute value can be thought of as the 'distance' of a value from
zero on the number line, and distance is always positive."
"The rule is:#str|-n|=|n|##str=n#. Can you apply that to #op#?"
"Some examples: #str|+42|=42#, #str|-42|=42#, and #str|0|=0#."
"To get the absolute value of a number such as #op#, we simply drop
any minus sign."))
....and get this:

(PROGN
(DEFMETHOD SKILL-TITLE ((TF-ID (EQL 'ABSOLUTE-VALUE)))
"Absolute Value")
(DEFMETHOD SKILL-ANNOTATIONS ((TF-ID (EQL 'ABSOLUTE-VALUE)))
"Take the absolute value of #op#." "The vertical bars around #op#
mean 'the absolute value of' #op#."
"Absolute value of #strn# is the 'distance' of #strn# from zero."
"Absolute value is always zero or positive: #strn=n#, and #str-n=n#.")
(DEFMETHOD SKILL-HINTS ((TF-ID (EQL 'ABSOLUTE-VALUE)))
"What do those vertical bars around #op# mean?" "Have you learned
about 'absolute value'?"
"Absolute value can be thought of as the 'distance' of a value
from zero on the number line, and distance is always positive."
"The rule is:#str-n=n##str=n#. Can you apply that to #op#?" "Some
examples: #str+42=42#, #str-42=42#, and #str0=0#."
"To get the absolute value of a number such as #op#, we simply
drop any minus sign."))

The above is how my upcoming death-defying interactive Algebra
tutor-in-a-drum ("You'll laugh! You'll cry!") will know how to coax some
befuddled teen through |-42| -42 if they get stuck. And a hundred
other subskills (so there will be a hundred of these definitions).

If I hire someone they will look at defskill and not fall to the ground
frothing at the mouth. They likely will not even macroexpand it because
it is self-explanatory. If they wonder if there are other options they
can alt-. to the source. The language has been extended, but I followed
a pattern familiar to Lispniks. Zero confusion results.

If I decide not to use generic method dispatch to "look up" the hints I
just have to change the macro and then write a DEFUN (no dispatch on
type) to, say, look up the symbol in a hash table.

hth,ken

ps. I won't mention the other benefit, which is that I want educators to
edit these if they have a better idea on how to tutor absolute value. I
am not mentioning it because I am as impatient with superfluous syntax
as a non-programmer would be. k

pps. How would Python do this? Is it possible to avoid committing to an
implementation mechanism? Compare and contrast. k

--
Algebra: http://www.tilton-technology.com/LispNycAlgebra1.htm

"Well, I've wrestled with reality for thirty-five
years, Doctor, and I'm happy to state I finally
won out over it." -- Elwood P. Dowd

"I'll say I'm losing my grip, and it feels terrific."
-- Smiling husband to scowling wife, New Yorker cartoon

[Paul Rubin]

Ken Tilton <ke*******@gmai l.comwrites:

pps. How would Python do this? Is it possible to avoid committing to
an implementation mechanism? Compare and contrast. k

You'd just write a function. Python's expression syntax is comparable
to a Lisp reader (you can have nested values of mixed types etc.) so
you can use Python expressions to initialize pretty much anything.

[greg]

Ken Tilton wrote:

pps. How would Python do this?

Here's one way it could look:

defskill("absol ute-value",
title = "Absolute Value",
annotations = [
"Take the absolute value of #op#.",
"The vertical bars around #op# mean 'the absolute value of' #op#.",
"Absolute value of #strn# is the 'distance' of #strn# from zero.",
"Absolute value is always zero or positive: #str|n|=n#, and #str|-n|=n#."
],
hints = [
"What do those vertical bars around #op# mean?",
"Have you learned about 'absolute value'?",
"""Absolute value can be thought of as the 'distance' of a value from
zero on the number line, and distance is always positive.""",
"The rule is:#str|-n|=|n|##str=n#. Can you apply that to #op#?",
"Some examples: #str|+42|=42#, #str|-42|=42#, and #str|0|=0#.",
"""To get the absolute value of a number such as #op#, we simply drop
any minus sign."""
]
)

Is it possible to avoid committing to an
implementation mechanism?

The defskill function could do just about anything with this.
Here's one possibility:

skills = {}

class Skill:
pass # fill in whatever methods you need here

def defskill(name, title, annotations, hints):
skill = Skill()
skill.title = title
skill.annotatio ns = annotations
skill.hints = hints
skills[name] = skill

This gives you a dictionary of Skill instances indexed by name,
each one having a title and lists of annotation and hint strings.
The rest of the system can process this however required.

--
Greg

[Ken Tilton]

greg wrote:

Ken Tilton wrote:

>pps. How would Python do this?

Here's one way it could look:

defskill("absol ute-value",
title = "Absolute Value",
annotations = [
"Take the absolute value of #op#.",
"The vertical bars around #op# mean 'the absolute value of' #op#.",
"Absolute value of #strn# is the 'distance' of #strn# from zero.",
"Absolute value is always zero or positive: #str|n|=n#, and
#str|-n|=n#."
],
hints = [
"What do those vertical bars around #op# mean?",
"Have you learned about 'absolute value'?",
"""Absolute value can be thought of as the 'distance' of a value from
zero on the number line, and distance is always positive.""",
"The rule is:#str|-n|=|n|##str=n#. Can you apply that to #op#?",
"Some examples: #str|+42|=42#, #str|-42|=42#, and #str|0|=0#.",
"""To get the absolute value of a number such as #op#, we simply drop
any minus sign."""
]
)

Is it possible to avoid committing to an
implementation mechanism?

The defskill function could do just about anything with this.
Here's one possibility:

skills = {}

class Skill:
pass # fill in whatever methods you need here

def defskill(name, title, annotations, hints):
skill = Skill()
skill.title = title
skill.annotatio ns = annotations
skill.hints = hints
skills[name] = skill

This gives you a dictionary of Skill instances indexed by name,
each one having a title and lists of annotation and hint strings.
The rest of the system can process this however required.

Ok, not too bad, not much syntax in there. But now I have a tougher
requirement for you, which I noticed only after posting. (I tried
running the damn thing and it whined about not knowing how to "reverse"
absolute-value (to clone one problem into a similar problem).) A
reversal must be able to yield any given a result, and sometimes must
use given operands already settled on by the larger reversing algorithm.
In the simpler case, to reverse absolute-value with result 42 we produce
either |42| or |-42|. In the more complicated case, the multiply-literal
reverser may discover 6 is an operand and 42 is the result (meaning it
does no randomization, it just supplies the (* 6 7) reversal. Why am I
telling you all this? I don't know. The point is, we need code (not just
data) in defskill (apologies for nasty formatting):

(defmacro defskill (id &body skill-info)
`(progn
,@(loop with sub-id = id
for (q . q-def) in skill-info
collecting (ecase q
((title annotations hints)
`(defmethod ,(intern (conc$ 'skill- q))
((tf-id (eql ',sub-id)))
(list ,@q-def)))
(reverse
`(defmethod tf-reverse ((id (eql ',sub-id))
resx opnds)
(declare (ignorable resx opnds))
,@q-def))))))

--------------- (Abbreviated) Example.... ------------------------------

(defskill absolute-value
(title "Absolute Value")
(annotations
"Absolute value is always zero or positive: #str|n|=n#, and
#str|-n|=n#.")
(hints
"What do those vertical bars around #op# mean?")
(reverse
(ensure-cloning resx
(make-instance 'mx-number
:value (loop with op1 = (car opnds)
with log = (max 1 (ceiling (log (abs (value op1)) 10)))
for n = (* (signum (value op1))
(+ 2 (random (expt 10 log))))
when (/= n (value op1))
return n)
:representation (representation resx)))))

-------------- Producing.... ---------------------------------
(progn (defmethod skill-title ((tf-id (eql 'absolute-value))) (list
"absolute value"))
(defmethod skill-annotations ((tf-id (eql 'absolute-value)))
(list "absolute value is always zero or positive: #strn=n#,
and #str-n=n#."))
(defmethod skill-hints ((tf-id (eql 'absolute-value)))
(list "what do those vertical bars around #op# mean?"))
(defmethod tf-reverse ((id (eql 'absolute-value)) resx opnds)
(declare (ignorable resx opnds))
(ensure-cloning resx
(make-instance 'mx-number :value
(loop with op1 = (car opnds) with log = (max 1 (ceiling
(log (abs (value op1)) 10))) for n =
(* (signum (value op1)) (+ 2 (random (expt 10
log)))) when (/= n (value op1)) return n)
:representation (representation resx)))))

How close can Python get when code is involved? The reverse function
signature is fixed, so can lambda help?

ken

--
Algebra: http://www.tilton-technology.com/LispNycAlgebra1.htm

"Well, I've wrestled with reality for thirty-five
years, Doctor, and I'm happy to state I finally
won out over it." -- Elwood P. Dowd

"I'll say I'm losing my grip, and it feels terrific."
-- Smiling husband to scowling wife, New Yorker cartoon

[Paddy]

Ken Tilton wrote:

(apologies for nasty formatting):

;-)

- Paddy!

[Ken Tilton]

Paul Rubin wrote:

Ken Tilton <ke*******@gmai l.comwrites:

>>don't know. The point is, we need code (not just data) in defskill
(apologies for nasty formatting):

Man that whole thing is messy. I can't for the life of me understand
why it's so important to use a macro for that. Even in Lisp, I'd
probably set up the reverse thingie as an auxiliary function.

And when you got to skill 42 and you discovered you needed a new
optional argument to the reversal method you would throw up your hands
and register for bartending school rather than go edit the other 41.

defskill is writing my code for me. When things change, I have it write
different code. Implementation is hidden, even from the programmer. I am
one step removed from the code when writing a macro. This is the "meta"
in metaprogramming .

ken

--
Algebra: http://www.tilton-technology.com/LispNycAlgebra1.htm

"Well, I've wrestled with reality for thirty-five
years, Doctor, and I'm happy to state I finally
won out over it." -- Elwood P. Dowd

"I'll say I'm losing my grip, and it feels terrific."
-- Smiling husband to scowling wife, New Yorker cartoon

[Paul Rubin]

Ken Tilton <ke*******@gmai l.comwrites:

Man that whole thing is messy. I can't for the life of me understand
why it's so important to use a macro for that. Even in Lisp, I'd
probably set up the reverse thingie as an auxiliary function.

And when you got to skill 42 and you discovered you needed a new
optional argument to the reversal method you would throw up your hands
and register for bartending school rather than go edit the other 41.

I don't see the problem. Python uses keyword args sort of like
Lisp's, and the called function (if it asks) receives a dictionary
containing any keyword args not bound explicitly in the arg list.
So you can invent new args whenever you want.

[Ken Tilton]

Ken Tilton wrote:

>

Paul Rubin wrote:

>Ken Tilton <ke*******@gmai l.comwrites:

>>don't know. The point is, we need code (not just data) in defskill
(apologies for nasty formatting):

Man that whole thing is messy.

I do not see much difference, except that the character count is 25%
less in the macro version:

(defskill absolute-value
(title "Absolute Value")
(annotations
"Absolute value of #strn# is the 'distance' of #strn# from zero."
"Absolute value is always zero or positive: #str|n|=n#, and
#str|-n|=n#.")
(hints
"Some examples: #str|+42|=42#, #str|-42|=42#, and #str|0|=0#."
"To get the absolute value of a number such as #signed-value#, we
simply drop any minus sign.")
(reverse
(ensure-cloning resx
(make-instance 'mx-number
:value (loop with op1 = (car opnds)
with log = (max 1 (ceiling (log (abs (value op1)) 10)))
for n = (* (signum (value op1))
(+ 2 (random (expt 10 log))))
when (/= n (value op1))
return n)
:representation (representation resx)))))

(defmethod skill-title ((tf-id (eql 'absolute-value)))
(list "absolute value"))

(defmethod skill-annotations ((tf-id (eql 'absolute-value)))
(list "absolute value of #strn# is the 'distance' of #strn# from zero."
"absolute value is always zero or positive: #strn=n#, and #str-n=n#."))

(defmethod skill-hints ((tf-id (eql 'absolute-value)))
(list "some examples: #str+42=42#, #str-42=42#, and #str0=0#."
"to get the absolute value of a number such as #signed-value#, we
simply drop any minus sign."))

(defmethod tf-reverse ((id (eql 'absolute-value)) resx opnds)
(declare (ignorable resx opnds))
(ensure-cloning resx
(make-instance 'mx-number :value
(loop with op1 = (car opnds) with log = (max 1 (ceiling (log (abs
(value op1)) 10))) for n =
(* (signum (value op1)) (+ 2 (random (expt 10 log)))) when
(/= n (value op1)) return n)
:representation (representation resx)))))
Let's lose the strings and count again, since they are a fixed cost. OK,
now the macro version is 30% shorter.

> I can't for the life of me understand
why it's so important to use a macro for that.

Pythonistas, when arguing about macros, always seem to forget that one
of the primary design imperatives of Python is cleaner code. Indentation
is use to avoid single characters { and }. But when macros come up you
all suddenly become the Mavis Beacon of programmers.

And, again, perhaps the bigger thing going on here is that the 30% is
boilerplate code representing implementation, which can change.

I don't know, perhaps the best argument against macros is that no
Pythonista wants them. That is actually a damn good reason.

ken

--
Algebra: http://www.tilton-technology.com/LispNycAlgebra1.htm

"Well, I've wrestled with reality for thirty-five
years, Doctor, and I'm happy to state I finally
won out over it." -- Elwood P. Dowd

"I'll say I'm losing my grip, and it feels terrific."
-- Smiling husband to scowling wife, New Yorker cartoon