Re: Seeking computer-programming job (Sunnyvale, CA)

[Phlip]

Agreed for some kinds of "people skills", but hustling to convince
total strangers to put out money to take a chance on hiring me
isn't at all the type of "people skills" needed by a software
programmer to interact with supervisor and co-designers.

Au contraire. When a boss thinks of a feature, they need to ask for an estimate
of the programmer hours required to implement it. If each little planning
session has the same meanings as a hiring interview, then maybe a good way to
face the interview is like a big planning session...

 

[Series Expansion]

OK, I see, its ok for you to personally attack me by claiming I lied

Well, it's kind of hard not to when you say something won't be a
personal atatck, and then spend four very long paragraphs telling the
whole world how stupid you think I am.

[many more personal attacks; rest of post deleted]

 

[Series Expansion]

Only if you forget than most other languages have more parentheses
than Lisp.  Java being C-like syntax-wise, I'd bet it uses more
parentheses than Lisp.  C does.

Nonsense -- wherever C uses braces, parentheses, OR brackets for
grouping, the equivalent Lisp code will use parentheses, parentheses,
and more parentheses, so C cannot possibly use more.

 

[Series Expansion]

This is impossible.

Exactly my point.

[lots snipped; talks about me in third person, insults me, several
other gross breaches of etiquette; even calls me a liar]

I am not.

 

[Series Expansion]

Ah! And here is the ultimate proof of what I said in the last post.
He's just misquoted you, just like that. Why would he do this? To make
you angry, that's why!

Lies and errors. These tiresome personal attacks do not constitute
rational arguments in favor of either Lisp or Java, gugamilare.

 

[Series Expansion]

Errors or outright lies.

Yes, I know he does like that only to make me angry.

Another one.

Unfortunately, it's hard to make me angry, I'm very stubborn, and I
can't stand people telling blatant lies and presenting them as
objective truth.

Looked in a mirror?

That said, I'm getting tired of this thread, and probably now it's so
huge that no one will ever want to read it, so no one has any chance
to become convinced by Series and Seamus' lies... so, mission
accomplished!

I have told no lies.

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, Alessio and gugamilare.

 

[Series Expansion]

He's pretty clearly insane.

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, Paul and gugamilare.

 

[Series Expansion]

[brain ****]

42

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, java.oke.

 

[Series Expansion]

Yes

OK, now that that's straightened out ...

Try it like this:
 (setq code '(let ((x arg-value)) (somefunc x) (otherfunc x)))
Then
 (setq new-code (subst '#:x 'x code))
[that is, replace occurences of X (the variable) in code with #:X (a
different, uninterned symbol...but the same one each time!)]  Now
  new-code  =>  (let ((#:x arg-value)) (somefunc #:x) (otherfunc #:x))

And you're back where you started. If you pasted that code into the
editor from this news-post, saved it to a file, and compiled it,
that'd be three separate #:xs there.

Yes..../if/ I pasted it into a text editor, saved it to a file, and
compiled it, that'd be three separate #:xs there.

And of course a macro processor is supposed to have the same effect:
as though it made its substitution of the macro's output for the
macro's invocation in the source code, after which the compiler
compiles said source code.

 But I wouldn't do that -- I'd compile it in the same Lisp image I did the
substitution in, where there's only one #:x, and then I wouldn't have a
problem.

Incoherent. The Lisp image is something that exists once you have a
compiled program and you run it, or you run it in the interpreter to
test it.

Unless you're using Lisp, in which case they will.

As already explained, they won't.

It would, if the source code were text.  But it isn't

But it must be. Source code MUST be text. It's not permitted to be
something else, or the sky falls, grep can't be used to search your
source tree, sed and non-Lisp-aware text editors can't safely
manipulate your sources, aliens invade, terminators come back in time
for you, Windows Indexing Service can't search into your source files,
and other such disasters.

It's not "rich-text"; it's not *text* at all.  It's Lisp objects:
lists, symbols, numbers, etc.  And yes, of course serializing it to
ASCII loses information.

This is disastrous. Source code should not be that way. Rich text is
bad enough but you're implying it's actually BINARY. I'd like to know
who thought THAT was a good idea.

The syntax is wrong

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, Paul.

but if you fix the syntax it /will/ cause FUNC to
be invoked on some-value because the #:G1959s /are/ the same.

No, they aren't. Try pasting that code at your REPL if you think
otherwise.

"more advanced editors"...hahah, good one!

It's been repeatedly admitted by emacs PROPONENTS that it is at least
ten years behind the times, interface-wise. (My own personal
experience suggests a value closer to 20.)

Regardless, it is a *text* editor. If, as you say, the source code for
Lisp programs is *not text*, then, without a special-purpose NON-text
editor for them, you're up the proverbial creek.

 

[Series Expansion]

Then you'd have to RTFM about *print-circle*.

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, Kaz.

See, you keep assuming that there isn't any more to Lisp than what you have
read so far in this Usenet thread.

No, I just keep assuming certain baseline, safe assumptions, one of
which is that source code is vanilla ASCII or, at worst (Java),
Unicode.

We don't know that. Two #:x symbols could be the same symbol or could
not.

They can inside the macro processor's brain. Once the output is
incorporated into the in-memory image of the source code and becomes
ordinary text, however, they will be separate.

Put this way: if I type
(foo #:x)
(blah #:x)
into the code and compile it, that's two #:xs.

Macros basically automate transforming pieces of code into other
pieces of code, so if you typed something like that often, you could
get a macro to do it for you, thus avoiding one of the things you
criticize Java for: boilerplate code. So, if a macro generated
(foo #:x)
(blah #:x)
into the code and I compiled it, that should also be two #:xs, since
the macro is supposed to simply be automating the effect of typing
that stuff repeatedly and saving me the bother.

If the code is machine generated by a macro, the #:x will be the same
symbol because the macro would have done this:

  (let ((x-sym (gensym)))
    `(let ((,x-sym value))
       (func ,x-sym)))

I.e it would allocate a single symbol and stick it into multiple places
in the generated code.

And when that code is fed to the compiler, it's multiple #:xs again.
Certainly, if you selected the above and pasted it in, it would be.
And certainly, manually replacing a macro invocation in your source
file with its expansion should not change the semantics of that code
(though it would invite stuff-getting-out-of-synch problems down the
line).

Yes, woe to you if you try to cut and paste that code back into Lisp.

Cutting and pasting code from one sourcefile to another shouldn't
alter semantics!! modulo the effects of enclosing scopes and
contextual imports.

When you enable *print-circle*, the Lisp printer will render objects into this
notation.

 [1]> (setf *print-circle* t)
 T
 [2]> (let ((x (cons 1 2))) (setf (cdr x) x))
 #1=(1 . #1#)

See, *print-circle* shows us that circular list has itself as its tail.  The ##
notation is capable of backpatching. The whole object can be associated with
#1, but #1# can also occur inside that object. Here, the object is a single
cons notated with the dot notation, and the CDR slot of the cell is the
cell itself (backpointer).

This hasn't solved your problem. Now the #1 in the output is the
potential source of a collision!

 

[Series Expansion]

No

Yes, source code resides in files. Of course, at the time the macro
processes it, it's working on an image in RAM, but the long-term
storage for source code is in disk files. This is something every
computer programmer should know.

Actual Lisp code is not textual, and it usually resides in memory
(though of course it could be dumped to files, but it probably
wouldn't be readable by humans).

You are describing object code of some sort. I am discussing source
code. Please try to stick to the topic.

survive across sessions.

No
Yes.

The most common way is that the programmer edits text
representing Lisp code, and then feeds this text to the Lisp
implementation, that "reads" (parses) it and produces the actual code.
The text itself of course gets saved in files.

This is called editing source code, feeding it to the compiler which
produces object code, and the source code gets saved in files.

I'm well aware of how source code, object code, and compilers
interrelate. This is a completely pointless and somewhat condescending
diversion from the original topic, modulo your somewhat odd
terminology. (Is there some reason for avoiding the industry-standard
terms "source code" and "object code"?)

Lisp source code instead is meant to be easily manipulated by a
programmer using Lisp itself. This is the basis for macros.

Which confirms that macros act on source code, not (as you seemed to
be implying at one point) object code.

You could edit Lisp code without ever modifying text, for
example by using a GUI application that shows the code as a tree.

Directly hacking object code? Not a very good idea, unless you don't
have the source code for whatever reason.

However, since text is much more versatile, I believe such a GUI will
never be the preferred way of writing Lisp code.

This doesn't follow -- a GUI can improve the usability of a text
editor, even though it is possible to implement a feasible-to-use (if
clumsy-to-use) text editor without one, whereas you couldn't, say,
implement Photoshop or something similar without a GUI.

 

[Paul Foley]

And of course a macro processor is supposed to have the same effect:
as though it made its substitution of the macro's output for the
macro's invocation in the source code, after which the compiler
compiles said source code.

Yes...since the "macro processor" is Lisp, and it doesn't attempt to
pointlessly write the expansion out to a file only to read it back in
again, it works fine.

[Although, as Kaz pointed out, it /is/ possible to write this sort of
thing in a file anyway...]

As already explained, they won't.

Odd that it seems to have been working on a daily basis for thousands
of people for several decades.

But it must be. Source code MUST be text. It's not permitted to be
something else,

"Not permitted"? Mad as a hatter, aren't you!?

It's been repeatedly admitted by emacs PROPONENTS that it is at least
ten years behind the times, interface-wise. (My own personal
experience suggests a value closer to 20.)

I've never seen an editor that comes close to Emacs, in terms of
usability. I don't care about talking paperclips.

 

[duane]

On May 25, 7:02 pm, Paul Foley <[email protected]> (http://
public.xdi.org/=pf) wrote:

[Hey, Paul, How's it going? I like your argumentation, and the fact
that you've kept a level head this last week or two with your answers,
despite the challenges.]

He's pretty clearly insane.

No, he's pretty clearly playing a game. The object of the game is to
keep the thread going as long as possible. He gives himself points
(i.e. the thread is still alive) for answering every post that looks
like they might be taken as a slight, and even some that can't (I love
the way he played the answer "42"... And he's not going to get
tired, because he doesn't have to think of clever twists to every
answer; he just plays the same tired recording over and over again in
order to drive others insane enough to send just one more answer
(which keeps the game going). Sprinkle that with a little on-topic
but flawed logic and you have yourself a very impressive volley.

The only way he loses his game is to lose his audience, which will
happen when everyone stops answering his posts, no matter how insane
and in need of an answer they seem to be. (Or, even more insidious,
no matter how sane but slightly flawed they seem to be - this catches
the ones who are sincerely trying to help him to understand; they
answer and keep the game going).

Duane

 

[java.oke]

[brain ****]

42

These tiresome personal attacks do not constitute rational arguments
in favor of either Lisp or Java, java.oke.

OK, Sorry for the Worry.

Now it's your turn (I'd suggest: "Sorry for Cross-Posting to c.l.l."
-- and I'm sure you meant the Clojure list --- and the "common" is
invisible in "comp.lang. .lisp").

 

[Tim X]

Well, it's kind of hard not to when you say something won't be a
personal atatck, and then spend four very long paragraphs telling the
whole world how stupid you think I am.

Well, it seems you want it both ways. In your first reply, you stated
you didn't read what followed, now your claiming it was 4 paragraphs
of me telling the world how stupid you are. Either you read it or you
did not.

Check it out again. I did NOT state you were stupid even once. In fact,
after the initial paragraph where I stated I was not making a personal
attack, I made only passing references to being mistaken. In fact, I
whent to considerable length not to try and make it appear personal
while at the same time trying to point out why your statements were in
error. The bulk of the e-mail was factural statements regarding the
current state of emacs.

It would seem that your so concerned about people thinking your stupid
that your makeing very basic errors in comprehension. I do not know you
and don't know whether your stupid or not, but the evidence does
indicate your overly defensive - to the point of interpreting any
attempt to correct any misinformation you have as a personal attack.
How would someone have to phrase a correction for you so that it is not
seen as a personal attack or do you never get anything wrong?

Tim

PS. I'm now very glad I didn't also correct your misinformation
concerning blind programmers and graphical UIs.

PPS. FYI I've been a blind programmer for over 10 years and do happen to
know a bit about it

 

[Marco Antoniotti]

Yes, source code resides in files. Of course, at the time the macro
processes it, it's working on an image in RAM, but the long-term
storage for source code is in disk files. This is something every
computer programmer should know.
Yes.



You are describing object code of some sort. I am discussing source
code. Please try to stick to the topic.



Yes.

Yes and no. You can compile a Common Lisp file into an "object
code". But the macroexpansion does without any temporary file being
written out to disk. Unlike the C preprocessor and its descendants.
Plus, Lisp (and Scheme) macro processors have the full equivalent of
the AST in memory to manipulate and eventually the CL compiler takes a
sequence of such representations in order to produce the resulting
object file (or not).

This is called editing source code, feeding it to the compiler which
produces object code, and the source code gets saved in files.

.... but not the result in the intermediate step of macroexpansion.

I'm well aware of how source code, object code, and compilers
interrelate. This is a completely pointless and somewhat condescending
diversion from the original topic, modulo your somewhat odd
terminology. (Is there some reason for avoiding the industry-standard
terms "source code" and "object code"?)

What odd terminology?

Which confirms that macros act on source code, not (as you seemed to
be implying at one point) object code.

Nope. Macros act on the equivalent of the AST of other programming
language; which in Lisp it happens to be a first class data type,
hence giving the language its power.

Directly hacking object code? Not a very good idea, unless you don't
have the source code for whatever reason.

Since there is a 1-1 (mostly) correspondence between code and data in
Lisp, that is possible. Maybe not desirable, but possible for sure.
Nothing forbids you to save the results as source code.

This doesn't follow -- a GUI can improve the usability of a text
editor, even though it is possible to implement a feasible-to-use (if
clumsy-to-use) text editor without one, whereas you couldn't, say,
implement Photoshop or something similar without a GUI.

Of course a GUI can improve the usability of a program. The point is
that a GUI that allows you to directly edit the AST of any program
instead of text may not be really useful. The fact that writing such
a GUI in Lisp is somewhat easier does not mean that it is something
that should be done.

Cheers

 

[Seamus MacRae]

That likely is what a person who didn't know anything about
s-expressions might think. Good point.

This looks like a personal attack with no logical purpose.

I shall provide you with a refresher on cons cells: they have two
pointers in them, called the address register and the decrement
register. Lists are implemented as unidirectional linked lists of cons
cells, with the decrement register pointing to the next list and the
address register to the list item. Hence the names -- address register
for the pointer to the list item, and decrement register for the pointer
to walk to get a one-shorter list, and eventually to reach the end of
the list.

Trees can also be represented, by pointing to more cons cells with the
address register, but a cons cell having only the two registers, these
trees are necessarily binary.

Other data structures, including higher-order trees, can be emulated by
various cumbersome means inside of a binary tree, but this is true of
all non-circular data structures. (And since cons cells can be made to
form circularities, in fact circular data structures can be implemented
on them as well -- but still only binary ones, or else emulated ones. A
fully general cons cell graph is a directed graph with unlimited
in-edges and max two out-edges per node.)

 

[Series Expansion]

On May 25, 7:02 pm, Paul Foley <[email protected]> (http://

public.xdi.org/=pf) wrote:

[Hey, Paul, How's it going? I like your argumentation, and the fact
that you've kept a level head this last week or two with your answers,
despite the challenges.]

He has not. Many of his posts have been laced with personal attacks,
at least implied ones.

No, he's pretty clearly playing a game.

c) None of the above.

 The object of the game is to keep the thread going as long as possible.

Actually, were it to end tomorrow, I would not be displeased, so long
as no attack on my character, expressed or implied, has gone
unrebutted.

 He gives himself points (i.e. the thread is still alive) for answering
every post that looks like they might be taken as a slight, and even
some that can't (I love the way he played the answer "42"...

As is so commonly the case with speculations made in a vacuum, this is
incorrect. Regarding specifically the post with the 42, there was also
an alteration to the quoted material in that post that suggested that
I was crazy, a "fuckhead", or similarly -- I don't recall exactly. It
was that, not the number, to which I was responding. Though now that
you mention it, the number was rather lacking in obvious relevance,
and appeared to constitute a non sequitur.

 And he's not going to get tired, because he doesn't have to think of
clever twists to every answer;

On the contrary, I put a great deal of thought into my
counterarguments, when presented with things reasonably approximating
rational arguments. It is only when presented with an obviously
logically void "argument" such as "Series Expansion is an idiot" that
I have responded with an uncreative copy-and-paste reply, and that
because there is nothing really to say in response to such an
"argument" except to point out that it fails to logically support the
conclusion that you wish people to draw.

Sprinkle that with a little on-topic but flawed logic and you have
yourself a very impressive volley.

Nothing is flawed about my logic, unlike, for instance, that of those
people who see an ad hominem argument as a valid one in support of
Lisp over Java.

The only way he loses his game is to lose his audience, which will
happen when everyone stops answering his posts, no matter how insane
and in need of an answer they seem to be.

None of them are either insane or, with the exception of those that
ask a question, in need of an answer.

 (Or, even more insidious, no matter how sane but slightly flawed
they seem to be

None of them are flawed, either.

 

[Series Expansion]

Well, it seems you want it both ways. In your first reply, you stated
you didn't read what followed, now your claiming it was 4 paragraphs
of me telling the world how stupid you are. Either you read it or you
did not.

I did not. I extrapolated its likely content after reading the first
sentence or two.

Check it out again. I did NOT state you were stupid even once.

No, I expect you merely implied it repeatedly, probably mixed in with
liberal quantities of other forms of irrational behavior.

In fact, I whent to considerable length not to try and make it appear
personal while at the same time trying to point out why your statements
were in error.

In other words, you went to considerable evidence to disguise the fact
that you were severely badmouthing me in public, while severely
badmouthing me in public. Hardly an admirable achievement worthy of
tooting one's own horn in this manner.

The bulk of the e-mail was factural statements regarding the current
state of emacs.

I believe you have misspelled "usenet article" and "counterfactual".

It would seem that your so concerned about people thinking your stupid
that your makeing very basic errors in comprehension.

These tiresome personal attacks do not constitute rational arguments
in favor of either emacs or Eclipse, Tim.

I do not know you and don't know whether your stupid or not, but the
evidence does indicate your overly defensive - to the point of
interpreting any attempt to correct any misinformation you have as a
personal attack.

I do not spread misinformation.

Furthermore, I do not agree with your assertions about "overly
defensive". Even if I did, a public forum is not the appropriate place
to be discussing such matters. In a public forum, I must always
present as perfect as possible an appearance, and therefore am
compelled to deny all claims of flaws, regardless of whether or not I
privately think there could be any truth to them. In other words, I
must maintain what is sometimes called "face", and "keep up
appearances". If you have something you wish to discuss with me that
is not appropriate for a public venue such as this, the gmail address
in my news headers is valid. Use it.

How would someone have to phrase a correction for you so that it is not
seen as a personal attack

They could do it privately.

PS. I'm now very glad I didn't also correct your misinformation

I repeat: I do not spread misinformation.

Do not post such a vile accusation again, or I may have to consider
taking legal action. Accusing someone of intentionally corrupt
conduct, where such is not the case, is a violation of defamation laws
in most jurisdictions.

PPS. FYI I've been a blind programmer for over 10 years

This confirms why your perceptions of the strengths and shortcomings
of various user-interfaces are abnormal. Rest assured that most people
do, and will continue to, find graphical interfaces easier and more
productive to use.

 

[anonymous.c.lisper]

On May 25, 7:02 pm, Paul Foley <[email protected]> (http://

public.xdi.org/=pf) wrote:

[Hey, Paul, How's it going? I like your argumentation, and the fact
that you've kept a level head this last week or two with your answers,
despite the challenges.]

He has not. Many of his posts have been laced with personal attacks,
at least implied ones.

I suppose claiming things that aren't personal attacks as personal
attacks doesn't constitute a personal attack?

c) None of the above.

logically, would you admit to it if you were?

Actually, were it to end tomorrow, I would not be displeased, so long
as no attack on my character, expressed or implied, has gone
unrebutted.

The only one doing damage to your public image is you. Replying with
the same copy-paste response does more to validate the flames than
ignoring them would.

As is so commonly the case with speculations made in a vacuum, this is
incorrect. Regarding specifically the post with the 42, there was also
an alteration to the quoted material in that post that suggested that
I was crazy, a "fuckhead", or similarly -- I don't recall exactly. It
was that, not the number, to which I was responding. Though now that
you mention it, the number was rather lacking in obvious relevance,
and appeared to constitute a non sequitur.

To some extent, it is crazy to argue so vigorously about something of
which you know very little...

On the contrary, I put a great deal of thought into my
counterarguments, when presented with things reasonably approximating
rational arguments. It is only when presented with an obviously
logically void "argument" such as "Series Expansion is an idiot" that
I have responded with an uncreative copy-and-paste reply, and that
because there is nothing really to say in response to such an
"argument" except to point out that it fails to logically support the
conclusion that you wish people to draw.

Your time would be better spent learning than counter-arguing.

Nothing is flawed about my logic, unlike, for instance, that of those
people who see an ad hominem argument as a valid one in support of
Lisp over Java.

The problem is that this thread has not been about 'Arguments favoring
lisp over java'.
It has been about correcting yours and Seamus MacRae's misconceptions
(which you state as fact) about Common Lisp.

And it has started appear to some, that these misconceptions may be
deliberate.
(To others it was apparent /literally/ weeks ago).