Notices by Vassil Nikolov | Васил Николов (vnikolov@ieji.de)

@weekend_editor wrote:
> didn't want to take the risk of re-writing working code

Jon L White once said rather matter-of-factly,
you never rewrite an old program,
you reimplements its primitives.

Also, all the compatibility notes in _Common Lisp: the Language_ are very Illuminating.

@amszmidt @AmenZwa

I had to look it up and restore my memory.

Real Programmers Don't Use PASCAL
Ed Post
Graphic Software Systems

contains:

"Besides, the determined Real Programmer can write FORTRAN programs in any language."

This _seems_ to be the original quote from 1982 (1983?).

@amszmidt @weekend_editor @AmenZwa

Fair enough, though "programmers can write FORTRAN in any language".
(I have forgotten who said that.)

@amszmidt @weekend_editor @AmenZwa

@weekend_editor wrote:
> looked like they discovered prog, and decided to hide Fortran inside it

"The program feature, as if it were impossible to write programs without it."
(GLS)

@amszmidt @AmenZwa

@jamie quoted:
> «Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features."»

Hmmm... how does this apply to the GNU Compiler Collection?

Briefly:

Firstly, "GNU's Not UNIX" comes from a very different context.

Secondly, the meaning of "not UNIX¹" is in the GPL sense, not in the engineering sense.
_________
¹ What was UNIX at the time and whose intellectual property was it?

@PaniczGodek @jamie

My point is:

One context is Stallman's drive (at the time):
Free Software, FSF, GPL, etc.
In other words, my view is that "GNU's Not UNIX" came out
first and foremost as a political slogan,
rather than an engineering one.

(Don't take my word for this, of course;
there are enough primary sources from those days.)

Another very different context is that of
"make it small to do one thing well", an engineering principle,
and in this context I gave GCC as a (counter)example.

@PaniczGodek @jamie

Make software that any fool can use
and only a fool will want to use it.
(This is very old; I don't have an attribution.)

Note that non-fools may _have_ to use such software, too.

#ComputerProgramming
#SoftwareEngineering

Indeed.

Now, how to make Jeff Atwood and those who listen to him take heed?
Regrettably, I don't know...
🙁

@aral

Was that the original instance of this joke (hack? abomination?)?

By the way, this may be older than the shared structure reader macros (sharpsign-equals and sharpsign-sharpsign).
It can be done with a macro.

This is a good interview question for language lawyers:
what _exactly_ in the language specification makes that invalid?

@weekend_editor @screwlisp

I agree, except the reader macros must be older, because _Common Lisp: the Language_ came out in 1984.

Maybe I'll try to find the place in the Hyperspec tomorrow morning.

Here is a minor compilable abomination:

(funcall (defun #1=#:f (n) "Write once, run once." (if (zerop n) 1 (* n (#1# (1- n))))) 5)
=> 120

#CommonLisp

@weekend_editor @screwlisp @BobKerns

@weekend_editor wrote:
> practical use in *source* code.

A rare use is for literals,
like
(mapcar #'+ xs '#1=(17 . #1#))
to add 17 to each x.

> if you're dumping a list structure to a file to be re-read later, you need to do this kind of structure-sharing.

Definitely.
And an important special case, as Screwlisp pointed out, is printing macroexpansions.
Possibly in an interactive session, of course.

NB: this also works for arrays (I don't remember about #S).

#Lisp

@jnpn @screwlisp @BobKerns

On static transfer of control ("go to") vs. dynamic non-local exits.
Guy Steele wrote in _Common Lisp: the Language_:
"a go can break up catchers".
I had to ponder this for quite some time to understand _why_ he pointed this out (at the time I didn't know well enough how some things work).

I think it is a good exercise.
The following is a bit of a spoiler,
but it is in the preceding sentence in the book:
a go is not always compiled into a simple machine jump instruction.

#CommonLisp
#Lisp

P.S.
Moscow didn't exist yet when Kievan Rus was founded (9th century).
Moscow was founded by Prince Yuriy Dolgorukiy some time about the year 1100.

"Yuriy" is a variant of "George".
"Dolgorukiy" means "having long arms" (as in upper limbs, not weapons).

@praetor @benroyce

@praetor wrote:
> about after the Rus were conquered

It gets complicated.
Briefly and incompletely:
There were rump Mongol states (also known as Tatars).
There was a lot of no man's land later and some of it got settled by runaway serfs (de facto slaves) from Russia and they and their descendants became the Cossacks.
They had a state in the 17th century, caught in between Ottoman Turkey, Poland, and Russia.
Eventually Russia conquered these lands in many stages over the 18th century.

@benroyce

Aside, I would say that handling strings in C (and C++) is difficult, because handling strings in assembly language is difficult.
And the latter is difficult, because handling strings on a conventional von Neumann machine is difficult.
As is handling anything that is not a machine word.

***

Making an implementation called True Common Lisp (TCL) would be too provocative.
(I am aware of the existence of T in the Lisp family.
I know Tcl just a bit.)

***

Flames to /dev/null.

@screwlisp @kasper

@Nonilex wrote:
> ... noted that the #Trump administration wants #ICE to make a minimum of 3,000 arrests a day

Like Stalin's regime, which set targets for the number of foreign spies arrested...
🙁

> wasn't that Lucid?

I don't know whether I understand the question.
From memory, XEmacs is a descendant of Lucid's clone of Emacs.

@anthk @nlupo @screwlisp

Scientifically,
ambiplectrophobia,
I presume.

@spiralganglion

[Origins of LOOP in #CommonLisp?]

@amszmidt

Thank you.

@kentpitman

Kent, would you happen to have anything on the authorship of the `loop' macro within easy reach?

@screwlisp