Subject: Re: Allegro compilation warnings
From: Erik Naggum <>
Date: 2000/10/19
Newsgroups: comp.lang.lisp
Message-ID: <>

* (Mario Frasca)
| as I told you, I'm working on code which has been developed by someone
| else.  I am trying to have it automatically compiled, but there were
| some circular dependencies in the sources, so I had to move some
| functions from one file to an other and I have 'announced' the
| dependencies in a set of require clauses at the beginning of each
| file, so that I can be satisfied of working with these sources.  

  The way the system was compiled should be dug up.  My hunch is it
  was all loaded in as source, and then compiled.  You can very easily
  do that yourself, and it's much, much easier than what you've been
  doing so far.

| for some reasons, I don't manage to understand all this apparent
| nonsense about the current package, since which is the current
| package at a certain point in my sources is not defined statically
| but dynamically and I'm not -yet- used to it.

  Well, first you dispense with the opiniated bullshit that it's
  "apparent nonsense".  To see why, judge how likely it is that you
  listen to what I said after I branded your opinion that way first.
  If you're really smart, it didn't affect you at all, figuring that I
  had my reasons to this very specific incident and that you could
  understand them -- the converse is not quite true for your reaction
  since it is not specific to anything anyone but you can determine.
  You continue to display irrational elements in your behavior towards
  the code you're working on.  Just what does it take to make you snap
  into a more rational approach?

  The current package is a read-time concept.  When Common Lisp loads
  a file, it reads one expression at a time, then evaluates it.  If
  that expression changes something in the global environment, it is
  available for the next expression to use.  The in-package macro sets
  *package* to the package named by its argument for the duration of
  the file as load creates a binding of *package* that is unwound when
  the file terminates.

  The current package is naturally _also_ a run-time concept, but it
  affects only functions that intern symbols in the current package,
  among them load and read, in addition to the actual function intern.
  If you don't use these functions in your own code, you don't have to
  worry about the current package at run-time, as all the symbols you
  need were interned at read-time.

  Compilation of the files loaded does not alter these facts, as the
  file compiler's responsibility is to ensure that the semantics of
  loading the file is retained.

| references to a language I understand are a means to understand a
| language I don't yet know well enough to express the things I want
| to express.

  How did you learn your first language?  Why was that such a lousy
  experience that everything must now be done relative to what you
  first learned?  _If_ it was such a lousy experience, I'm loathe to
  believe that you know your first language all that well.  If you had
  no problems at all learning your first language, why not repeat the
  success?  Either way, to base learning a new language on old stuff
  seems like a plan to lose.  Part of learning that first language was
  to learn to _think_ in that language.  If you don't learn to _think_
  in the next language you set out to "learn", you won't ever manage
  to get your head around its concepts.  That means what is called a
  "suspension of disbelief" in reading normal literature, i.e., the
  willingness to enter the universe of the book on its own premises.
  If you can't do _that_ successfully, you won't ever make a good
  programmer in any language.

  And how come you had the patience to wait until you did know the
  first language well enough before you attempted something, but now
  you don't have that patience?  Or _didn't_ you have that patience to
  begin with?  A lot of people don't really possess the tinest shred
  of the personal quality of real patience that is required to be good
  at _anything_, least of all precision crafts such as programming or,
  say, target shooting (which I recently picked up because I run out
  of patience with computer programming at times :).

| If I was developing from scratch, I would use those parts of the
| language I know, and study the ones I come across as I need them.

  Why is this a bad approach if you are not developing from scratch?

| having to modify a complex interaction of poorly written sources is
| as if you had to modify a bad Albanian text into a good Albanian
| piece of poetry, you allow me to think in Italian while studing the
| subtelties of that language?  thanks.

  I don't believe you really understand what it means to think in a
  programming language, nor have the patience to acquire that skill,
  so I'll just give up now.

| please, don't speak M$ to me.  if you know it, you avoid it.

  I "speak M$" to you?  Geez.  How the hell is it possible _not_ to do
  something wrong to you, Mario Frasca?  I don't have the time to
  pander to someone whose sensibilities are so erratically tuned and
  who displays such a staggering lack of _reqiured_ patience.  I would
  really suggest you do something other than programming computers.

  I agree with everything you say, but I would
  attack to death your right to say it.
				-- Tom Stoppard