Python syntax in Lisp and Scheme

[Doug Tolton]

On Mon, 06 Oct 2003 17:12:18 GMT, Alex Martelli <aleax at aleax.it>
wrote:

>Imagine a group of, say, a dozen programmers, working together by
>typical Agile methods to develop a typical application program of
>a few tens of thousands of function points -- developing about
>100,000 new lines of delivered code plus about as much unit tests,
>and reusing roughly the same amount of code from various libraries,
>frameworks, packages and modules obtained from the net and/or from
>commercial suppliers.  Nothing mind-boggling about this scenario,
>surely -- it seems to describe a rather run-of-the-mill case.
>
>Now, clearly, _uniformity_ in the code will be to the advantage
>of the team and of the project it develops.  Extreme Programming
>makes a Principle out of this (no "code ownership"), but even if
>you don't rate it quite that highly, it's still clearly a good
>thing.  Now, you can impose _some_ coding uniformity (within laxer
>bounds set by the language) _for code originally developed by the
>team itself_ by adopting and adhering to team-specific coding
>guidelines; but when you're reusing code obtained from outside,
>and need to adopt and maintain that code, the situation is harder.
>Either having that code remain "alien", by allowing it to break
>all of your coding guidelines; or "adopting" it thoroughly by,
>in practice, rewriting it to fit your guidelines; is a serious
>negative impact on the team's productivity.

Alex, this is pure un-mitigated non-sense.  Python's Metaclasses are
far more dangerous than Macro's.  Metaclasses allow you to globally
change the underlying semantics of a program.  Macros only allow you
to locally change the Syntax.  Your comparison is spurious at best.

Your argument simply shows a serious mis-understanding of Macros.
Macros as has been stated to you *many* times are similar to
functions.  They allow a certain type of abstraction to remove
extraneous code.

Based on your example you should be fully campaigning against
Metaclasses, FP constructs in python and Functions as first class
objects.  All of these things add complexity to a given program,
however they also reduce the total number of lines.  Reducing program
length is to date the only effective method I have seen of reducing
complexity.

If you truly believe what you are saying, you really should be
programming in Java.  Everything is explicit, and most if not all of
these powerful constructs have been eschewed, because programmers are
just too dumb to use them effectively.


Doug Tolton
(format t "~a@~a~a.~a" "dtolton" "ya" "hoo" "com")