Are there conventions for organizing Lisp source code? In particular
how do you break source code up by file and how do you organize your
files in a directory structure? Does it depend on what implementation
you are using or are the general standards?
I suppose I could just make something up that suits my needs but that
part of my brain has atrophied somewhat after several years of Java
programming. (Java's class and package system more or less mandates a
certain file organization.) And I'd rather not reinvent the wheel with
pointy corners.
-Peter
--
Peter Seibel
·····@javamonkey.com
"Peter Seibel" <·····@javamonkey.com> wrote in message ···················@javamonkey.com...
> Are there conventions for organizing Lisp source code? In particular
> how do you break source code up by file and how do you organize your
> files in a directory structure? Does it depend on what implementation
> you are using or are the general standards?
>
I'm not aware of any standards, but I can describe what we did on our
last big project.
The code implemented a `change control' system that allowed you to model
changes. (Something like CVS on steroids.) There were several logical
divisions in the code: a `core' layer that implemented `versioned CLOS
classes', the `version management' layer that implemented `projects,
branches, and versions', the `file system' layer that used the versioned
CLOS and the version management layer to implement a version managed
file system model, a `server' layer that co-ordinated interaction between
the clients and the file system model, and a `utility' layer that contained
a whole bunch of stuff that was used everywhere and didn't `belong' to
any one subsystem.
Each layer had its own package and its own subdirectory under the
root. In addition, there were subdirectories for the build process,
for static web pages, and for the java client.
It was largely ad-hoc in that we didn't have an algorithm for
deciding what went there, but on the other hand it seemed logical
and obvious to us.
Peter Seibel <·····@javamonkey.com> writes:
> Are there conventions for organizing Lisp source code? In particular
> how do you break source code up by file and how do you organize your
> files in a directory structure? Does it depend on what implementation
> you are using or are the general standards?
>
> I suppose I could just make something up that suits my needs but that
> part of my brain has atrophied somewhat after several years of Java
> programming. (Java's class and package system more or less mandates a
> certain file organization.) And I'd rather not reinvent the wheel with
> pointy corners.
IMHO Java does have some merit in mandating a certain file
organization.
Anyway, the way I do things follows in this pattern.
1 - set up a MK:DEFSYSTEM early
2 - have at least the following directory structure (IMHO single-file
systems are evil)
program.system
program-pkg.lisp
impl-dependent/
<vendor dependent code ges in here>
sub-module1/
...
sub-module2/
Of course you can add other amenities (shameless plug: CL-CONFIGURATION
from the CLOCC), and your revision control system of choice.
Having one CLOS class per file may or may not be good. It depends.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
"Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
>
> IMHO Java does have some merit in mandating a certain file
> organization.
>
The idea of storing your code in a hierarchical database is good.
Using the file system as a cheesy implementation of a hierarchical
database is bad.
"Joe Marshall" <·············@attbi.com> writes:
> "Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
> >
> > IMHO Java does have some merit in mandating a certain file
> > organization.
> >
>
> The idea of storing your code in a hierarchical database is good.
> Using the file system as a cheesy implementation of a hierarchical
> database is bad.
Of course a hierarchical data base would be the best way to go. But
the Java solution is better than nothing.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
"Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
>
> "Joe Marshall" <·············@attbi.com> writes:
>
> > "Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
> > >
> > > IMHO Java does have some merit in mandating a certain file
> > > organization.
> > >
> >
> > The idea of storing your code in a hierarchical database is good.
> > Using the file system as a cheesy implementation of a hierarchical
> > database is bad.
>
> Of course a hierarchical data base would be the best way to go. But
> the Java solution is better than nothing.
I suppose it is better than no structure whatsoever, but it isn't a
good solution. The file system is for storing files (at least that's what
I hear. You'd think it'd be better at it.) The file system is
*far* too inflexible for configuration management.
It is a much better idea to let the file system store the files, and let
some other tool handle the configuration management.
"Joe Marshall" <·············@attbi.com> writes:
> "Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
...
> > Of course a hierarchical data base would be the best way to go. But
> > the Java solution is better than nothing.
>
> I suppose it is better than no structure whatsoever, but it isn't a
> good solution. The file system is for storing files (at least that's what
> I hear. You'd think it'd be better at it.) The file system is
> *far* too inflexible for configuration management.
I would tend to agree. I just do not have a clear picture of
"configuration management". My original remark was in the direction
of your first paragraph. The Java way is better than the
"nothing-way" of CL and C/C++. Adopting Java-like conventions makes
you life easier.
> It is a much better idea to let the file system store the files, and let
> some other tool handle the configuration management.
I have to agree here. However, you are adding an extra layer between
the programmer and the "host system" (quotes mandatory).
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
"Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
>
> "Joe Marshall" <·············@attbi.com> writes:
>
> > "Marco Antoniotti" <·······@cs.nyu.edu> wrote in message ····················@octagon.mrl.nyu.edu...
> ...
>
> > > Of course a hierarchical data base would be the best way to go. But
> > > the Java solution is better than nothing.
> >
> > I suppose it is better than no structure whatsoever, but it isn't a
> > good solution. The file system is for storing files (at least that's what
> > I hear. You'd think it'd be better at it.) The file system is
> > *far* too inflexible for configuration management.
>
> I would tend to agree. I just do not have a clear picture of
> "configuration management". My original remark was in the direction
> of your first paragraph. The Java way is better than the
> "nothing-way" of CL and C/C++. Adopting Java-like conventions makes
> you life easier.
Oh sure, a Java-like convention can be a great aid, but having the software
tools rigidly *enforce* the convention is terrible.
Let me give you an example. Where I used to work we had a `java client'
for our software. This client came in two forms: a java application
that could be downloaded and run on the command line, and a java applet
that ran under the browser. Because our system did file-system
manipulation, the applet had to be `signed'. The java application did
not have to be signed as it didn't run in the `sandbox'.
There are two common conventions for enabling applets to run outside the
`sandbox': The Netscape Object Signing package, which is a set of class
files that allow your application to ask for permission as needed, and
`Authenticode' signing that enumerates the permissions the client needs.
There is a third convention for HotJava, but I don't know anything about it.
Since Java has an impoverished file system interface, we needed to not
only step `outside the sandbox' but also `outside of java'. (For
example, java.io.File has a canRead and a canWrite method for querying
the read-only state of the file, but there is no method for *modifying*
that state!) There are a couple of mechanisms for doing this, but for
the sake of portability we wanted to avoid using `native code' (we'd
have to maintain seperate C libraries for each platform, and the whole
point of using java was so that we wouldn't have to do this!) We opted
to use the ability of java to invoke other programs (like chmod) through the
java.lang.runtime exec method.
Microsoft's Java virtual machine has a `foreign function interface' that
makes it trivial to invoke native file system functions. A significant
number of users have this installed, so it made sense to wrap the
extended file system capabilities in an abstract class that would call
the native file system code if it were available and invoke commands
externally through the exec method otherwise. Since the Sun java machine
doesn't have an interface to the MS ffi, you can't load the code that
uses that ffi into a Sun Java. So the code has to use the java reflection
mechanism to load up the appropriate classes on the fly.
So ultimately, we had to deliver the client code in 4 formats:
Unsigned application for MS Java
Unsigned application for Sun Java
Netscape signed applet (Sun Java) (jar file)
MS signed applet (MS Java) (cab file)
Both the JAR and the CAB file format support hierarchical pathnames.
Because Java expects and requires hierarchical pathnames, the class
files *must* retain their relative position in the hierarchy. The
standard mechanisms for creating signed JAR and CAB files start at
a directory and bundle and sign everything underneath it.
We don't want to include the MS specific stuff in the Sun jar file,
nor do we want to include the Sun specific stuff in the MS cab file.
Since we had both applets and applications sharing components, we
wanted to partition the common code from the `wrapper'. Furthermore,
since some of the code was `third party' (the netscape javascript
classes), we wanted to keep that under a separate directory tree, too.
Symbolic links are problematic under windows. The solution is either
to replicate the entire directory structure for each `end product',
which would destroy the ability to share components, or put
everything into a single directory, which would make it difficult
to use the signing tools, add too much excess crap to each
application, and mingle our original code with third-party code.
For each configuration of the software, it was relatively easy to
describe what needed to go in the package, but the problem was
that Java wanted the file system layed out differently for each
configuration, and none of the layouts were compatible with our
own desired use of the file system.
(Our solution? Some hairy lisp code! We set up the directory
structure the way we wanted, then the lisp code would read a
configuration file that described the components that went into
a particular applet. The lisp code would compile the java code
and supply the appropriate classpath values to the command line
so the code would compile. Then it would create a temporary
directory hierarchy, copy the various class files to their correct
position within the hierarchy, and sign the directory. Logical
pathnames were a big win here.)
Joe Marshall wrote:
>
> For each configuration of the software, it was relatively easy to
> describe what needed to go in the package, but the problem was
> that Java wanted the file system layed out differently for each
> configuration, and none of the layouts were compatible with our
> own desired use of the file system.
>
> (Our solution? Some hairy lisp code! We set up the directory
> structure the way we wanted, then the lisp code would read a
> configuration file that described the components that went into
> a particular applet. The lisp code would compile the java code
> and supply the appropriate classpath values to the command line
> so the code would compile. Then it would create a temporary
> directory hierarchy, copy the various class files to their correct
> position within the hierarchy, and sign the directory. Logical
> pathnames were a big win here.)
This is pretty much what Ant is for. (Though perhaps it didn't
have all the capabilities you needed at the time.)
"Carl Gay" <·······@attbi.com> wrote in message ······················@attbi.com...
> Joe Marshall wrote:
> >
> > For each configuration of the software, it was relatively easy to
> > describe what needed to go in the package, but the problem was
> > that Java wanted the file system layed out differently for each
> > configuration, and none of the layouts were compatible with our
> > own desired use of the file system.
> >
> > (Our solution? Some hairy lisp code! We set up the directory
> > structure the way we wanted, then the lisp code would read a
> > configuration file that described the components that went into
> > a particular applet. The lisp code would compile the java code
> > and supply the appropriate classpath values to the command line
> > so the code would compile. Then it would create a temporary
> > directory hierarchy, copy the various class files to their correct
> > position within the hierarchy, and sign the directory. Logical
> > pathnames were a big win here.)
>
> This is pretty much what Ant is for. (Though perhaps it didn't
> have all the capabilities you needed at the time.)
From the Ant FAQ:
``Ant expects you to place your source files in a directory hierarchy
that mirrors your package hierarchy and to point Ant to the root of
this directory tree with the srcdir attribute.''
``Ant is not the only tool that expects a source-tree layout like this.''
And here is some Ant code:
<target name="cond" depends="cond-if,cond-else"/>
<target name="check-cond">
<condition property="cond-is-true">
<and>
<not>
<equals arg1="${prop1}" arg2="$${prop1}" />
</not>
<not>
<equals arg1="${prop2}" arg2="$${prop2}" />
</not>
<equals arg1="${prop3}" arg2="$${prop3}" />
</and>
</condition>
</target>
<target name="cond-if" depends="check-cond" if="cond-is-true">
<echo message="yes"/>
</target>
<target name="cond-else" depends="check-cond" unless="cond-is-true">
<echo message="no"/>
</target>
It can even generate DTD's for your build. Although,
``It may even be an invalid DTD. As Ant allows tasks writers to define
arbitrary elements, name collisions will happen quite frequently...''
I am not making this up.
"Joe Marshall" <·············@attbi.com> writes:
> And here is some Ant code:
[Amazing bogosity removed]
> I am not making this up.
I know. Incredible, isn't it? I don't like "me too" posts, but
Ant is _amazing_. I mean, _make_ is bad enough, but to re-invent
it so *badly* takes considerable talent. As if humans wanted
to program in XML!
Bring on a good DEFSYSTEM.
Alain Picard <·······················@optushome.com.au> writes:
> Bring on a good DEFSYSTEM.
Define "good".
I like `asdf', but I would, I wrote it. There's also Marco's
mk-defsystem 4, which is billed as a complete rewrite of the current
version 3
- http://ww.telent.net/cliki/asdf
- http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/clocc/clocc/src/defsystem-4/README?rev=HEAD&content-type=text/vnd.viewcvs-markup
-dan
--
http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources
Daniel Barlow <···@telent.net> writes:
> Alain Picard <·······················@optushome.com.au> writes:
>
> > Bring on a good DEFSYSTEM.
>
> Define "good".
* Anything with syntax I have a hope of understanding 6 months after I
write the rules.
* Anything which doesn't barf over itself if I put in a space instead of a tab
* Anything which can reason about multiple self-consistent plans and pick
an arbitrary one instead of just dying from indecision
Alain Picard <·······················@optushome.com.au> writes:
> Daniel Barlow <···@telent.net> writes:
>
> > Alain Picard <·······················@optushome.com.au> writes:
> >
> > > Bring on a good DEFSYSTEM.
> >
> > Define "good".
>
> * Anything with syntax I have a hope of understanding 6 months
> after I write the rules.
>
> * Anything which doesn't barf over itself if I put in a space
> instead of a tab
[Heh. I think I heard that they realized at some point in the initial
deplyment of 'make' that the tab/space thing was a problem and wanted
to go back and fix it, but there were already 10 or 20 deployed users
(can't remember exactly, but the number was this order of magnitude)
and they didn't want to disrupt such a large number of people by
making a 'gratuitous' change. (My telling of the story is approximate
and from memory; if anyone has a pointer to a truer telling, they should
post it here.)]
> * Anything which can reason about multiple self-consistent plans
> and pick an arbitrary one instead of just dying from indecision
Can you elaborate on this last?
Have you read
http://world.std.com/~pitman/Papers/Large-Systems.html
and does its protocol-layer address this? Or are you saying you're
looking for a syntax?
My personal take (and why I wrote that paper) is that people need the
flexibility to disagree on syntax, and that that's why the protocol layer
is what should be made standard.
Also, while offering cross-references,
http://world.std.com/~pitman/CL/Issues/defsystem.html
contains the proposal that went before X3J13. This document
cross-references
http://world.std.com/~pitman/CL/Issues/defsystem-notes.html
which contains my personal notes on what the committee said about the
proposal at the time. [Not that my personal notes are an official
record or without bias, but they are at least contemporaneous accounts.]
Personally, I tried using MK:DEFSYSTEM about 8 months ago and found it
both full of bugs and lacking in support I needed, to the point that I
found it difficult to separate implementation from spec. I don't say this
to disparage the effort, but to note that there are probably multiple layers
at which this converstation must take place, and they need to be separated.
e.g., "Protocol layer vs syntax layer" is one layer (several sub-issues:
is separating these right? which layer should be standardized? what are the
appropriate qualities of the layers that are determined need standards?),
and "Specification vs Implementation" is another (making sure people don't
form opinions on the basis of a bug, since bugs are transient, or a lack
of featurism, since featurism can be added).
Kent M Pitman <······@world.std.com> writes:
> My personal take (and why I wrote that paper) is that people need the
> flexibility to disagree on syntax, and that that's why the protocol layer
> is what should be made standard.
i suspect many people who actually thought about the issue would agree with
this. there was a little known attempt to extract out the guts of the make
engine so that other make-like tools could be written. i may be able to find
a reference. anyhow, even though make does not really scale well, and is
deficient in dependency and "build" expressiveness, many people insist on
putting more and more bletcherous features and structures on top of it. it
is amazing (and depressing) the type of contortions many software companies
get into just to get make to build their product. a good friend who has been
working on this topic (and arguing against make) since eighties calls this
"the tyranny of adequacy." his alternative system QEF [a free version was
included in an EUUG tape during late eighties under the name "dtree" - if
anyone has those tapes online, please let me know] is worth reading about
as well. some of his papers are in www.qef.com/html/additional.html
[online usenix proceedings have some papers on other make-like tools and
variants that are now lost in the mists of computing. that recent thing
called ant is not much better, IMO.]
oz
---
imagined forest -
we would be lost
without it. [oz/2002]
Kent M Pitman <······@world.std.com> writes:
> [Heh. I think I heard that they realized at some point in the initial
> deplyment of 'make' that the tab/space thing was a problem and wanted
> to go back and fix it, but there were already 10 or 20 deployed users
> (can't remember exactly, but the number was this order of magnitude)
> and they didn't want to disrupt such a large number of people by
> making a 'gratuitous' change. (My telling of the story is approximate
> and from memory; if anyone has a pointer to a truer telling, they should
> post it here.)]
i checked with a few friends at the labs, but they could not recall
this story. did not check with feldman. make came out with v7. if the
deployed users had been different internal departments, with some time
invested in replacing many build scripts with make, the impact of the
'gratuitous' change may have been larger than the numbers suggest.
quarter of a century later, it is hard to tell...
oz
--
a technology is indistinguishable from
its implementation. -- marshall rose
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230063265383789@naggum.net>
* ozan s yigit <··@blue.cs.yorku.ca>
| i checked with a few friends at the labs, but they could not recall
| this story. did not check with feldman. make came out with v7. if the
| deployed users had been different internal departments, with some time
| invested in replacing many build scripts with make, the impact of the
| 'gratuitous' change may have been larger than the numbers suggest.
| quarter of a century later, it is hard to tell...
What a sad testament to the ability of Unix tools to process text. sed,
ed, shell scripts, find, whatever, and they _still_ could not figure out
how to change the syntax of the input files to a program like that? One
has to wonder if the cobbler's children are indeed barefoot.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
ozan s yigit <··@blue.cs.yorku.ca> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> > My personal take (and why I wrote that paper) is that people need the
> > flexibility to disagree on syntax, and that that's why the protocol layer
> > is what should be made standard.
>
> i suspect many people who actually thought about the issue would agree with
> this. there was a little known attempt to extract out the guts of the make
> engine so that other make-like tools could be written.
Maybe I'm misunderstanding, but if you read the paper, you'll see the
parts you're seeming to be talking about (the dependency processing engine)
are exactly NOT the part I'm talking about being protocol...
It is surely the case that 'make' has the deficiency of being very
single-purpose and the paper discusses his deficiency; that problem
is 'fixed' by just having one make-file per task, i suppose. but the
problem of not wanting to use a makefile is not as easily fixed if
the recipient is used to calling make. (I guess you could make a simple
make file that just had one task to do, but...)
The actual dependency stuff 'make' does is of no personal interest to
me at all, really. It's probably fine--maybe even quite helpful--but it's
'detail'.
What matters to me is just having a function like load-system or
print-system which is implemented any way someone wants.
In fact, the first thing _I_ would want to do if I had separate protocol
support is to make a version of 'make' that just used 'sh' instead
of all that baggage--that is, that just substituted an imperative
script for the complicated dependency junk.
>i may be able to find
> a reference. anyhow, even though make does not really scale well, and is
> deficient in dependency and "build" expressiveness, many people insist on
> putting more and more bletcherous features and structures on top of it. it
> is amazing (and depressing) the type of contortions many software companies
> get into just to get make to build their product. a good friend who has been
> working on this topic (and arguing against make) since eighties calls this
> "the tyranny of adequacy."
What a great term.
> his alternative system QEF [a free version was
> included in an EUUG tape during late eighties under the name "dtree" - if
> anyone has those tapes online, please let me know] is worth reading about
> as well. some of his papers are in www.qef.com/html/additional.html
>
> [online usenix proceedings have some papers on other make-like tools and
> variants that are now lost in the mists of computing. that recent thing
> called ant is not much better, IMO.]
No comment here.
Kent M Pitman <······@world.std.com> writes:
? Maybe I'm misunderstanding, but if you read the paper, you'll see the
? parts you're seeming to be talking about (the dependency processing engine)
? are exactly NOT the part I'm talking about being protocol...
ok, i'll look at the paper again soon. i skimmed it a while ago.
? [...]
? In fact, the first thing _I_ would want to do if I had separate protocol
? support is to make a version of 'make' that just used 'sh' instead
? of all that baggage--that is, that just substituted an imperative
? script for the complicated dependency junk.
right, others have tried that sort of thing too, though i would have to
look around for references; one that jumps to mind is an inside-out tool:
a fully functional shell called mash (part of the inferno system) that can
load a make module to specify make-like rules for instance. i don't think
it can specify the relationships and dependencies in an imperative way,
though.
oz
---
the problem with being avant-garde is knowing who's putting on who. -- calvin
ozan s yigit <··@blue.cs.yorku.ca> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> > [Heh. I think I heard that they realized at some point in the initial
> > deplyment of 'make' that the tab/space thing was a problem and wanted
> > to go back and fix it, but there were already 10 or 20 deployed users
> > (can't remember exactly, but the number was this order of magnitude)
> > and they didn't want to disrupt such a large number of people by
> > making a 'gratuitous' change. (My telling of the story is approximate
> > and from memory; if anyone has a pointer to a truer telling, they should
> > post it here.)]
>
> i checked with a few friends at the labs, but they could not recall
> this story. did not check with feldman. make came out with v7. if the
> deployed users had been different internal departments, with some time
> invested in replacing many build scripts with make, the impact of the
> 'gratuitous' change may have been larger than the numbers suggest.
> quarter of a century later, it is hard to tell...
Hmm. Curious. I'll see if I can track down a source at my end. I think I
remember who told me this. In any case, it'd be a shame if it weren't true.
So many of the best teaching tales turn out on close examination to be false.
Then again, I saw a nice talk on storytelling at the MIT biz school in which
the assertion was made that it is better to tell a good story than a true one.
(That flies against comp.lang.lisp tradition of demanding references when
people assert that the sky is blue, of course...)
Kent M Pitman <······@world.std.com> writes:
> So many of the best teaching tales turn out on close examination to be false.
on the plus side, there are good, verifiable tales that are also useful
for teaching. evolution of scheme, common lisp, darwin awards... 8-)
oz
--
faster, better, cheaper, same old management - pick any three. -- h. spencer
Kent M Pitman <······@world.std.com> writes:
> Hmm. Curious. I'll see if I can track down a source at my end. I think I
> remember who told me this. In any case, it'd be a shame if it weren't true.
> So many of the best teaching tales turn out on close examination to be false.
> Then again, I saw a nice talk on storytelling at the MIT biz school in which
> the assertion was made that it is better to tell a good story than a true one.
Stories do not have to be true to be useful. I doubt that any of Aesop's
tales were actually true, but they endure and provide insights.
> (That flies against comp.lang.lisp tradition of demanding references when
> people assert that the sky is blue, of course...)
Such a demand is usually a challenge - one that usually goes unanswered.
I personally prefer to research and _provide_ references. By, the way,
the sky is _not_ always blue.
References?
http://world.std.com/~mmcirvin/bluesky.html
:-)
--
Duane Rettig Franz Inc. http://www.franz.com/ (www)
1995 University Ave Suite 275 Berkeley, CA 94704
Phone: (510) 548-3600; FAX: (510) 548-8253 ·····@Franz.COM (internet)
Duane Rettig <·····@franz.com> writes:
> I personally prefer to research and _provide_ references.
that is great, and appreciated. but what do you do when other people
casually claim things that you cannot with some reasonable effort find
any support for? if the claim is not explained in a way that indicates
expertise in the field, one would have to ask for references. i happen
to think that discussions in a usenet comp.group need to have somewhat
firmer grounding than the discussions about the nature of capricorn
vs aquarius. :)
oz [on usenet since 83]
---
the power of the unaided human mind is highly overrated. -- donald norman
[sorry for being off-topic...]
ozan s yigit <··@blue.cs.yorku.ca> writes:
> Duane Rettig <·····@franz.com> writes:
>
> > I personally prefer to research and _provide_ references.
>
> that is great, and appreciated. but what do you do when other people
> casually claim things that you cannot with some reasonable effort find
> any support for?
I think you partially answer your own question:
> if the claim is not explained in a way that indicates
> expertise in the field, one would have to ask for references.
Yes, the first step is to try to find references yourself, to honsestly
see if you can corroborate the other person's claim. If that fails,
the next step is to ask for references. However, it is always hard to
ask for references on the 'net, because people can't see your body
language, and what you might have meant as "I've searched all of the
places I know, and can't find the basis for your statement. Will you
help me?" ends up being taken as "You are absolutely wrong, and I
challenge you to find anything that proves your claim to be right". That
second interpretation is easier to make, because more often than not,
it was the intended meaning - as I said in my previous post, requests
for references are usually taken as a challenge. So if you really
intend the first meaning, you usually have to make it very clear,
sometimes including your reason for wanting the reference so that it
disarms a potentially defensive position which the other person has
taken.
The last step should never be to argue endlessly with the person. After
a reasonable number of exchanges, one must recognize the fact that
opinions will not be changed, and that it is not important who gets the
last word. As an argument goes on and on, there comes a point where
both sides look foolish, the one who is right and the one who is wrong
(and which one was that anyway? Who knows? Who cares? :-)
> i happen
> to think that discussions in a usenet comp.group need to have somewhat
> firmer grounding than the discussions about the nature of capricorn
> vs aquarius. :)
Yes, I agree, but the only person I can control on the net is myself.
So I recognize the fact that people will argue the nature of capricorn
vs aquarius, and strive not to contribute to it myself.
> oz [on usenet since 83]
Duane [on usenet since ... before 83]
--
Duane Rettig Franz Inc. http://www.franz.com/ (www)
1995 University Ave Suite 275 Berkeley, CA 94704
Phone: (510) 548-3600; FAX: (510) 548-8253 ·····@Franz.COM (internet)
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230067718916717@naggum.net>
* ozan s yigit
| if the claim is not explained in a way that indicates expertise in the
| field, one would have to ask for references.
Asking for references is an expression of passive-aggressive hostility.
Asking for help to understand something, indicates that you are willing
to trust the person you are talking to to be able to explain things to
you, instead of telling him that you do not trust him at all. If the
person you are talking to is honest, he will run out of explanations if
you ask decent, honest, reasonably intelligent questions (i.e., not the
kind that a certain nutcase keeps asking over and over), and defer you to
other sources, but if you start off with such a request, you have given
very specific reason for the person you ask to believe that you do, in
fact, not trust him to be able to answer your questions, so you do would
not even bother to try. Also note that the nutcase who keeps asking for
references never looks them up -- his later questions betray that he has
expended no effort at all trying to grasp anything on his own. This is
quite common on USENET.
The reason these people ask for references is that it is, precisely, a
hostile move on their part, but those who are not particularly bright,
believe it is some useful academic ritual, the failure to comply to which
is some sort of technical defeat, and so the requestor scores a point
with the leering dumb guys in the audience. Why this is valuable to
these people, I have yet to understand. "All these stupid people agree
(or laugh) with me, so I must be right"; to coin a term for this, let me
call it dumbocracy.
To go off on a tanget, the combination of mass agreement and stupidity is
probably the most dangerous element in popular Western culture, and such
things as the American electorate actually going and electing George
W. Bush president have already made it harder for those with better than
average intelligence to be heard. Incidentally, the last line of my
signature is from a CNN article:
http://www.cnn.com/2002/TECH/science/04/30/science.understanding.ap
So why do people ask for references? They obviously think it works well
to humiliate someone despite strong evidence to the contrary. One may
speculate that have come up short in their own research or have found
some references that turned out to be completely bogus and have been hurt
by it. Instead of providing their own references to debunk something
they do not believe to be true, they find it much more rewarding to
pretend that others fail to prove their point if they can ask for and
then mock their references.
All in all, a hostile request for references is a pretty indecent and
dishonest way of derailing the open information exchange: Instead of
letting people think aloud freely, the likes of our resident nutcase will
jump up and ask for references for anything at all, but randomly. Such
hostility has a much stronger effect on how people feel about posting and
contributing than a strong, directed response to particular issues. It
is a systematic attack on those who have independent ideas, and only
those who are so much in the mainstream as not to be worth listening to,
go free of such passive-aggressive attacks. Given an unexpected, but
correct answer to a question, the reference-requestor will ask for
references, but not for the expected, but incorrect answer. It matters
more to people who know the correct answer to document it than it does to
people who post incorrect answers -- the result of not caring much about
anything to begin with. It usually takes much more time to look things
up than to answer from memory, but this confidence and trust is shot to
pieces by the reference-requestor cum nutcase, who prefers that people
who do not have correct answers post their random guesswork. In my view,
the motivation for asking for references is to make it easier in the long
run for the nutcase to spread dis- and misinformation and not be opposed
-- also notice how the resident nutcase requests references only when he
wants the opposite position to be true, but does nothing to show that.
The same issue that I discussed about people who ask for proof all the
time applies to references. Very little of what we know to be true can
be _economically_ proven to be so. That is, even if you could prove it,
it is not in the interest of an open information exchange to raise the
cost of posting to that which requires proof. What we do is let people
post various things they believe to be true, and then debunk it if it is
not, with real facts and references. So little is provably true, but so
much of what people believe is provably false, that it is far more
productive to let people think freely and meet resistance than it is to
force people to subject their opinions to resistance before the fact,
which is what providing an iron-clad proof essentially is. The key is
not to repeat known falsehoods. People who do that, however, do have a
tendency to demand proof and references from those who debunk them. Our
resident nutcase has done this several times, and things have just died
or turned ugly because people tire of explaining the same things to the
same guy over and over. Through the persistence of unchecked stupidity,
it would appear in google searches and the like that the nutcase wins by
number of matches, unchallenged claims, and the like. This is a fairly
sinister way of attacking the base of a community's common trust in what
it knows to be true. Then again, the nutcase lost his faith in Lisp and
did not follow up by moving to another community, such as Python's, so
one has some reason to suspect sinister, long-term destructiveness just
there.
So if you want references, provide references for your own views. Look
things up to debunk what other people have posted. If you ask others for
references, but do not actually document your need for them, and do not
thank the person for providing them, etc, it is only hostile.
--
in a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
On Sat, 11 May 2002 01:01:59 GMT,
Erik Naggum <····@naggum.net> wrote:
> * ozan s yigit
>| if the claim is not explained in a way that indicates expertise in the
>| field, one would have to ask for references.
>
> Asking for references is an expression of passive-aggressive hostility.
You once replied to a message with "Don't post your beliefs as facts".
>
> Asking for help to understand something, indicates that you are willing
> to trust the person you are talking to to be able to explain things to
> you, instead of telling him that you do not trust him at all. If the
This does not need to be such a black and white decision, you know.
I think that you have both deep and broad knowledge of all things
concerning Lisp. But I do not think that you have patience enough
to explain things to people starting from different premises.
> person you are talking to is honest, he will run out of explanations if
> you ask decent, honest, reasonably intelligent questions (i.e., not the
> kind that a certain nutcase keeps asking over and over), and defer you to
> other sources, but if you start off with such a request, you have given
> very specific reason for the person you ask to believe that you do, in
> fact, not trust him to be able to answer your questions, so you do would
Or I might just want to see your sources so that I can try to arrive
at my own conclusions without being influenced by your train of thought.
Or I might think that your view is right and that I want to promote
it in other places, but need more generally accepted proof than "private
communication in usenet newsgroups".
Some time ago, I posted in a side note that I had read an online article that
the MS XP EULA prohibits the use of vnc to display XP-desktops on non
MS-sanctioned computers. Shortly after I received a note asking for the
URL, because the poster wanted to use this fact to influence some decision
in his company. Hostility? Not at my end of the line.
> not even bother to try. Also note that the nutcase who keeps asking for
> references never looks them up -- his later questions betray that he has
> expended no effort at all trying to grasp anything on his own. This is
> quite common on USENET.
>
> The reason these people ask for references is that it is, precisely, a
> hostile move on their part, but those who are not particularly bright,
> believe it is some useful academic ritual, the failure to comply to which
> is some sort of technical defeat, and so the requestor scores a point
> with the leering dumb guys in the audience. Why this is valuable to
> these people, I have yet to understand. "All these stupid people agree
> (or laugh) with me, so I must be right"; to coin a term for this, let me
> call it dumbocracy.
This last paragraph is once again a rhetorical rehearsal of your
opinion that everybody not agreeing with you is stupid.
>
> To go off on a tanget, the combination of mass agreement and stupidity is
> probably the most dangerous element in popular Western culture, and such
> things as the American electorate actually going and electing George
> W. Bush president have already made it harder for those with better than
> average intelligence to be heard. Incidentally, the last line of my
> signature is from a CNN article:
> http://www.cnn.com/2002/TECH/science/04/30/science.understanding.ap
>
> So why do people ask for references? They obviously think it works well
> to humiliate someone despite strong evidence to the contrary. One may
If you are honestly trying to teach other people you should be
prepared to give references for whatever reason they are asking
them.
> speculate that have come up short in their own research or have found
> some references that turned out to be completely bogus and have been hurt
> by it. Instead of providing their own references to debunk something
> they do not believe to be true, they find it much more rewarding to
> pretend that others fail to prove their point if they can ask for and
> then mock their references.
How should they provide references when have none? They might
be trying to learn something, and asking for references is a
valid means of doing this. Of course, they could always try for
themselves and search the web, but it is a well known time-saver
to start with references provided by somebody else, be it the
bibliography in a book, links on a website or participants in
usenet groups.
>
> So if you want references, provide references for your own views. Look
> things up to debunk what other people have posted. If you ask others for
> references, but do not actually document your need for them, and do not
> thank the person for providing them, etc, it is only hostile.
Only if you live in a hostile environment.
Regards,
S.
>> person you are talking to is honest, he will run out of explanations if
>> you ask decent, honest, reasonably intelligent questions (i.e., not the
>> kind that a certain nutcase keeps asking over and over), and defer you to
>> other sources, but if you start off with such a request, you have given
>> very specific reason for the person you ask to believe that you do, in
>> fact, not trust him to be able to answer your questions, so you do would
> Or I might just want to see your sources so that I can try to arrive
> at my own conclusions without being influenced by your train of thought.
To give a concrete example supporting your point:
I teach a introductory Lisp course. One of my students very
frequently will ask for references. For instance, when I recently
discussed the difference between &optional and &rest, he wanted to
know where he could look in the HyperSpec or Aluminum Book to get this
information.
I know perfectly well that he's not asking to be aggressive, or
because he doesn't believe me. And he's not hurting me or the class
by asking. Instead, he's wanting to more effectively use the other
resources that he has available. It's really a great help.
Cheers,
joelh
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230115917999148@naggum.net>
* Joel Ray Holveck <·····@juniper.net>
| I teach a introductory Lisp course.
On a newsgroup? On _this_ newsgroup? Do you "teach" the concept of
context, too?
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
From: Thien-Thi Nguyen
Subject: Re: How do you organize your source code?
Date:
Message-ID: <kk9elgibl0k.fsf@glug.org>
Erik Naggum <····@naggum.net> writes:
> On a newsgroup? On _this_ newsgroup? Do you "teach" the concept of
> context, too?
if discussion isn't for learning, what is it for?
thi
Thien-Thi Nguyen wrote:
> if discussion isn't for learning, what is it for?
Many things that look like discussions are not.
Eric is correct that many so-called discussions are simply knife fights
disguised under a veneer of politeness. This is especially true of many
"academic" rituals (like asking for references in an informal setting)
where the rigor and knowledge of the one who asks is elevated simply by his
taking the offensive. It is simply a debased form of argument from
authority - debased because the authority that the one who asks gains from
the ploy is as virtual as his argument usually is.
faa
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230115794872622@naggum.net>
* Stefan Schmiedl <·@xss.de>
| You once replied to a message with "Don't post your beliefs as facts".
Yes, and it appears to be in strong need of repeating to some people.
| This does not need to be such a black and white decision, you know.
Maybe you should apply some of your gray matter, then.
| I think that you have both deep and broad knowledge of all things
| concerning Lisp. But I do not think that you have patience enough to
| explain things to people starting from different premises.
I'm missing the part where you explain why I should care what you think.
> The reason these people ask for references is that it is, precisely, a
> hostile move on their part, but those who are not particularly bright,
> believe it is some useful academic ritual, the failure to comply to which
> is some sort of technical defeat, and so the requestor scores a point
> with the leering dumb guys in the audience. Why this is valuable to
> these people, I have yet to understand. "All these stupid people agree
> (or laugh) with me, so I must be right"; to coin a term for this, let me
> call it dumbocracy.
| This last paragraph is once again a rhetorical rehearsal of your
| opinion that everybody not agreeing with you is stupid.
But that is not my opinion, you fucking idiot. Of course, you are so
monumentally stupid that you think you can legitimately "disagree" what
somebody else's opinion is, right? The one person you would never listen
to is the person you have made up your mind what thinks, right? Such is
the nature of the stupidity that I have a very strong distaste for, yet
you guys are so fantastically retarded that you are not even aware of
your stupidity.
Anyone intelligent enough to read, knows that your crap here is only your
own lack of intellect showing through, because I disagree with you _and_
because you _are_ unintelligent. These are quite unrelated facts. The
need for you retards to keep repeating this point makes me believe that
it is a powerful self-defense mechanism. "No, no, I'm not stupid, I'm
just disagreeing with gravity and physics in general."
| Only if you live in a hostile environment.
You _are_ the hostile environment around here. Please die, Stefan. And,
please, make as little noise about your exit as possible. That, too, is
off-topic here, you see. The other option, to start thinking, is of
course completely irrelevant to even _suggest_ to something like you.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
On Sat, 11 May 2002 14:23:18 GMT,
Erik Naggum <····@naggum.net> wrote stuff I won't repeat here.
Well, Erik.
Actually I am astonished that you read this post, as I am "a totally
waste of time", remember?
And thanks for confirming the part about "not enough patience".
>
> Anyone intelligent enough to read, knows that your crap here is only your
> own lack of intellect showing through, because I disagree with you _and_
> because you _are_ unintelligent.
Do you have any references for this?
Oh wait. I should try and dig proofs up to debunk this myth.
> These are quite unrelated facts. The
> need for you retards to keep repeating this point makes me believe that
> it is a powerful self-defense mechanism. "No, no, I'm not stupid, I'm
> just disagreeing with gravity and physics in general."
Well, sometimes I *do* disagree with physics in general.
For example there are two different theories regarding the extent
of the universe and its age. One is generally acknowledged, another
explains human observations in a much easier way.
And, BTW, Galileo and Einstein did disagree with physics and gravity,
as known and accepted at their respective times, too.
>
>| Only if you live in a hostile environment.
>
> You _are_ the hostile environment around here. Please die, Stefan. And,
Now really, Erik. What would my wife or kids say?
Please let me rephrase my sentence:
Only if you choose to live in a hostile environment.
If you think that comp.lang.lisp is not big enough for the both of us,
you might want to consult your newsreaders manual to find out about
automatic deletion of offending threads. Please note that I do not ask
you to leave, I just ask you to follow up on your intention to ignore me.
> please, make as little noise about your exit as possible. That, too, is
> off-topic here, you see. The other option, to start thinking, is of
> course completely irrelevant to even _suggest_ to something like you.
Without Regards,
Stefan
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230121938911755@naggum.net>
* Stefan Schmiedl <·@xss.de>
| This last paragraph is once again a rhetorical rehearsal of your
| opinion that everybody not agreeing with you is stupid.
You know, since you retards have such a huge problem with this, maybe you
need to be told what really goes on. I doubt it will help, considering
that the only people who invoke the "disagree clause" are just plain
nuts, but let me at least try:
First, I voice my disagreement with what I believe is misinformation,
i.e., information contrary to reasonably established truth, such as stale
and known falsehoods, repeated falsehoods about which people agree, etc.
At this point, the person I disagree with has not yet been ddetermined to
be either evil or stupid or retarded. I just disagree, and say so.
Second, the person who posted the misinformation is the one who actually
cannot deal with contrary views and disagreement, and takes it personally,
including, but not limited to posting his opinions about me, as if that
could possibly help -- now I know he is really out of his mind.
Third, I probably not so gently point out that I am not interested in his
personal opinions on anything, particularly not me, and could he please
do something to explain or defend his position, instead of himself?
The person in question generally does absolutely everything _but_ explain
why what he posted should be considered true, reacting instead like a
five-year old kid who is much more concerned that people do not "believe"
him than to _make_ them believe him. Basic debate skills, like actually
making a coherent argument, are OUT. The strong need for this person to
have people agree with _him_, as opposed to his _positions_ on something,
now emerges as the primary reason for posting to a public forum, and lack
of such agreement backed by a rebuttal of his point is considered hostile
and a personal attack, no matter how it is phrased. If the whining loser
can find an excuse to think it is personal, he will seize upon it. Since
the dumber you are, the more you may believe that I would dislike you
from the start, which is not unreasonable considering that I have been
quoted quite widely for saying this:
I'm bothered by the fact that stupid people don't
spontaneously combust, which they should. -- Erik Naggum
<····@naggum.no>, comp.lang.lisp, 07Mar99.
dumb people post with considerable angst of being verbally brutalized,
and so react in advance to what they believe will happen, no matter what
_actually_ happened. (Remember, they are stupid, so this monumental
idiocy does not trouble them at all.) In the end, they remain defiant in
believing what they believed to begin with, unchanged, and all they
remember (because they are so stupid) is that (1) I disagreed with them,
(2) they were both stupid and called on it, and (3) it hurts a lot.
Thus is the myth they already believed to begin with self-reinforcing.
However, this is what happens when I disagree with you and you are more
intelligent than a cornered hamster:
First, I voice my disagreement with what I believe is misinformation,
etc, just like above.
Second, the person who posted the alleged misinformation _either_ sees
that he was mistaken and may shut up or apologize, _or_ explains what he
meant and where he came from, probably fully answering my objections.
Third, if there is a third, I may see his point and agree with it or at
least see it as a legitimately different view on something, and may shut
up or say so, _or_ I argue why the explanation does not hold water and
point to contradictory information. Generally, the second stage repeats,
with ever more obscure points of difference until ...
Fourth, we have arrived at a philosophical point of difference that may
either yield significant insight in a flash, lend more credence to the
hopes of life on other planets and interstellar travel and many other
wild things, or, most likely, show that either side is running out of
arguments and knowledge and relevance to the forum.
At no point in this exchange is the intelligence of the person who
disagrees in _evidence_. More likely than not, intelligent people who
discuss things, arrive at a common understanding.
When the lack of intelligence on the part of either side becomes a
problem, then and only then does it enter into the evidence and become an
issue. Failure to grasp something after repeated explanations that other
people understand and appreciate, is a problem only with the participant
in the debate, and no longer the arguments.
People who _continue_ to disagree with facts _are_ stupid.
People who _continue_ to disagree with me because they think it is some
sort of personal defeat to concede a point to me, _are_ stupid.
People who do not even listen to what I say because they have made up
their mind that anything I say is a personal attack, _are_ stupid.
Moreover, people who are unable to defend their position, but only defend
themselves (usually by attacking others), are _nuts_. People who have to
make up horrible things about their opponent because reality is not bad
enough that they can escape the conclusion that _they_ are the bad guy,
are literally going mad and turn out to be permenantly insane more often
than not.
Then there are the people who think that because I do not generally post
misinformation myself, I am never mistaken or _believe_ that I am never
mistaken because they do, and they cannot fathom that it is possible to
avoid making mistakes a lot, because they make mistakes all the time.
However, the reason is: I check things before I _post_. I am the kind of
guy who actually owns, reads, and uses dictionaries, reference works,
standards and specifications, and I am sufficiently well aware of my
level of certainty with something that I do not generally _post_ some
half-cooked guesswork. I go check it on my own. I hate wasting time on
idiots who post guesswork and never learn to stop doing it, so in a
public forum, I do not post if I do not know the answer and am pretty
sure it is a correct answer. I have a very solid reputation for knowing
all kinds of stuff and generally for reporting on them with as good
accuracy as would a scientist or an established authority, and this is
limiting me in many ways, because it is harder for me to think aloud than
for most other people. However, my true and honest distaste for people
who post things that they could easily have found out on their own by
expending _less_ effort than they used to post their bogus nonsense, is
probably infinite. I know that it does show, but how do you avoid my
mythical or real wrath? It is really very, very simple: Know your own
stuff, explain it or defend it if need be, and do _not_ be the first to
go personal. Stupid people cannot figure this out, of course, and the
more stupidly concerned stupid people are with "proper behavior", the
less they see how things start and what _merits_ nice treatment, and the
more willing they are to blame me for all ills on the planet, especially
if they are the retarded moralist type who _only_ posts when he can
attack me for something he is too goddamn stupid to understand. You are
that kind, if I recall correctly, Stefan Schmiedl.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
"Stefan Schmiedl" <·@xss.de> schrieb im Newsbeitrag
···················@ID-57631.news.dfncis.de...
> How should they provide references when have none? They might
> be trying to learn something, and asking for references is a
> valid means of doing this. Of course, they could always try for
> themselves and search the web, but it is a well known time-saver
> to start with references provided by somebody else, be it the
> bibliography in a book, links on a website or participants in
> usenet groups.
He,he. Have you ever seen an author of so called "new age" crap who can give
you any reference? Go to your local library and look into a book about Ufos
and the like; you will not see any reference there.
Look, it is easy: Eric has his television box, a computer and a newsnet
account. He does not need more in order to become intelligent. He does not
know how a peer reviewed article looks like. My cat Felix sometimes shows me
some of its stunts. And so behaves Eric too.
Why not ignore him? He is really irrelevant. Or is Naggum your Lisp
distributor? Or inventor of Lisp? Or author of your Lisp teaching material?
No.
Regards,
S. Gonzi
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3230123199111059@naggum.net>
* "Siegfried Gonzi" <···············@kfunigraz.ac.at>
| Look, it is easy: Eric has his television box, a computer and a newsnet
| account. He does not need more in order to become intelligent. He does
| not know how a peer reviewed article looks like. My cat Felix sometimes
| shows me some of its stunts. And so behaves Eric too.
This is the kind of conclusions that people who confuse what their very
limited intelligence can think up with reality. This is the kind of
people I have to endure in spades. The magnitude of the evil I have to
suffer because of the massive idiocy of such creep probably does not
quite register with people who have never seen it happen, but think for
yourself. How would _you_ react to something like this fucked-up mental
case? Granted, Siegfried Gonzi is obviously unable to deal with anything
he cannot first force-fit into his very limited coping ability, but he
and that "Biep" shit and others of similar moral constitution just _have_
to express themselves in public.
| Why not ignore him? He is really irrelevant. Or is Naggum your Lisp
| distributor? Or inventor of Lisp? Or author of your Lisp teaching
| material? No.
I am _so_ fucking tired of people who have to post their fantastically
moronic explanations of me. I am obviously so important to them in their
lives that they have to _post_ about me and what they cannot do on their
own. That I have some opinions that go against their retarded views, is
so important that they _have_ to attack me like Siegfried Gonzi and this
Stefan Schmiedl character do.
Fuck it.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
On Sat, 11 May 2002 16:26:39 GMT,
Erik Naggum <····@naggum.net> wrote:
>
> I am _so_ fucking tired of people who have to post their fantastically
> moronic explanations of me. I am obviously so important to them in their
> lives that they have to _post_ about me and what they cannot do on their
> own.
There are not that many people around who have uttered a death wish
against me in public. So you have made yourself very special to me.
> That I have some opinions that go against their retarded views, is
> so important that they _have_ to attack me like Siegfried Gonzi and this
> Stefan Schmiedl character do.
If you can't stand reading news, why do you still do it?
You don't have to put yourself under this continuing stress.
s.
Kent M Pitman <······@world.std.com> writes:
[make whitespace sensitivity]
> Hmm. Curious. I'll see if I can track down a source at my end. I think I
> remember who told me this. In any case, it'd be a shame if it weren't true.
If memory serves correctly, this story is told in the Unix-Haters
Handbook (I can't confirm this any longer, somebody "borrowed" my
copy). Not that that's necessarily where you heard it, but it does
suggest that the story has widespread currency
-dan
--
http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources
Daniel Barlow <···@telent.net> writes:
> If memory serves correctly, this story is told in the Unix-Haters
> Handbook (I can't confirm this any longer, somebody "borrowed" my
> copy).
ah. interesting. i've been told on occasion that one constant at the labs
at those days was "what is done is done, live with it." meaning that even
if the numbers were smaller (may 74 unix users group was attended by about
two dozen people from about a dozen institutions; june 75 meeting had fourty
people from twenty institutions) it may not have mattered. [i suggest those
who are really curious about these issues outside rhetorical points should
get in touch with peter salus, dennis ritchie or brian kernighan and ask
for their perspective.]
oz
---
the average pointer, statistically, points somewhere in X. -- hugh redelmeier
Daniel Barlow <···@telent.net> writes:
> If memory serves correctly, this story is told in the Unix-Haters
> Handbook (I can't confirm this any longer, somebody "borrowed" my
> copy).
I didn't find this story in my copy, starting from the index entries
on make and a few other likely keywords. Not that this disproves
anything of course.
...Peder...
--
Cogito ergo panta rei.
Peder O. Klingenberg wrote:
> I didn't find this story in my copy, starting from the index entries on
> make and a few other likely keywords. Not that this disproves anything
> of course.
>
It's not in the index, but it is in the book, on page 185. The text
describes a group at BBN who apparently repeatedly submitted code that
fixed the make whitespace sensitivity feature to Berkeley, and
repeatedly had it ignored. At the end of this section, the Stu Feldman
story is mentioned, parenthetically and prefaced with "According to
legend,".
So, it's still apocryphal, but dead-trees apocryphal.
Bob Bane <····@removeme.gst.com> writes:
> It's not in the index, but it is in the book, on page 185.
So it is. Thanks for the reference. I really have to reread that
book sometime.
...Peder...
--
Cogito ergo panta rei.
Bob Bane wrote:
>
> It's not in the index, but it is in the book, on page 185. The text
> describes a group at BBN who apparently repeatedly submitted code that
> fixed the make whitespace sensitivity feature to Berkeley, and
> repeatedly had it ignored. At the end of this section, the Stu Feldman
> story is mentioned, parenthetically and prefaced with "According to
> legend,".
>
> So, it's still apocryphal, but dead-trees apocryphal.
Amazed that apparently no one else asked Stu Feldman, I finally did
and here is (part of) what he had to say:
+---
|Then, use of Make took off, and in a few weeks after writing version 2 of
|the program (a week or so after version 1), I had a thriving user community
|of well over ten people (mostly friends). At that point, I didn't want to
|upset anyone by changing (upgrading) the syntax. The number of users has
|of course since multiplied by 10 another 5 or 6 times, so this was a bad
|bit of conservatism (and I have used this example when teaching software
|engineering).
+---
So there! Aren't you sorry to see another legend get killed by facts?!
-- bakul
Daniel Barlow <···@telent.net> writes:
> Alain Picard <·······················@optushome.com.au> writes:
>
> > Bring on a good DEFSYSTEM.
>
> Define "good".
>
> I like `asdf', but I would, I wrote it. There's also Marco's
> mk-defsystem 4, which is billed as a complete rewrite of the current
> version 3
We're using asdf here on a complex project (700+ lisp file). It works
well. A few times I've had to read the source to clarify points of
design and I could tell what was being done.
--
John Michael Adams
"Joe Marshall" <·············@attbi.com> writes:
> I suppose it is better than no structure whatsoever, but it isn't a
> good solution. The file system is for storing files (at least that's what
> I hear. You'd think it'd be better at it.) The file system is
> *far* too inflexible for configuration management.
> It is a much better idea to let the file system store the files, and let
> some other tool handle the configuration management.
I don't understand your statement. Surely, the unix filesystem IS a
"hierarchical database"? But if you mean that tools like CVS make
moving files around directories a nightmare, then I'm all with you.
Alain Picard <·······················@optushome.com.au> writes:
> "Joe Marshall" <·············@attbi.com> writes:
>
> > I suppose it is better than no structure whatsoever, but it isn't a
> > good solution. The file system is for storing files (at least that's what
> > I hear. You'd think it'd be better at it.) The file system is
> > *far* too inflexible for configuration management.
>
> > It is a much better idea to let the file system store the files, and let
> > some other tool handle the configuration management.
>
> I don't understand your statement. Surely, the unix filesystem IS a
> "hierarchical database"? But if you mean that tools like CVS make
> moving files around directories a nightmare, then I'm all with you.
On a side and OT. I used PRCS and it was heaven compared to CVS.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
Drew McDermott <··············@yale.edu> writes:
> Peter Seibel wrote:
>
> Are there conventions for organizing Lisp source code? In
> particular how do you break source code up by file and how do
> you organize your files in a directory structure? Does it
> depend on what implementation you are using or are the general
> standards?
>
> The key issues for organizing Lisp code (in my opinion) are:
>
> 1. How do you organize code into packages?
>
> 2. Where do you put datatype definitions (defstruct and defclass)?
[snip a bunch of good advice]
Thanks, that was just the kind of thing I was looking for. What about
macros? I read somewhere that it's a good idea/convention to put the
in a separate file. But it's also nice to keep them with the code that
uses them as they're likely to change together, at least early in
development. Any advice there?
-Peter
From: Erik Naggum
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3229591519949365@naggum.net>
* Drew McDermott
| <!doctype html public "-//w3c//dtd html 4.0 transitional//en">
Could you please post your messages in normal text format?
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
Drew McDermott <··············@yale.edu> writes:
> <!doctype html public "-//w3c//dtd html 4.0 transitional//en">
> <html>
> In response to complaints about HTML, I'm posting this again, hopefully
> in plain-text mode.
> <p>Peter Seibel wrote:
> <blockquote TYPE=CITE>Are there conventions for organizing Lisp source
> [...]
Nope, it's still HTML.
Edi.
From: Drew McDermott
Subject: Re: How do you organize your source code?
Date:
Message-ID: <3CD6F07D.B5B05C72@yale.edu>
Edi Weitz wrote:
>
> Drew McDermott <··············@yale.edu> writes:
>
> > <!doctype html public "-//w3c//dtd html 4.0 transitional//en">
> > <html>
> > In response to complaints about HTML, I'm posting this again, hopefully
> > in plain-text mode.
> > <p>Peter Seibel wrote:
> > <blockquote TYPE=CITE>Are there conventions for organizing Lisp source
> > [...]
>
> Nope, it's still HTML.
>
> Edi.
Help! I'm trapped in HTML! It's some kind of divine punishment for
reading newsgroups in Netscape and not Gnus.
-- Drew McDermott
In <·················@yale.edu>,
Drew McDermott <··············@yale.edu> wrote:
| Help! I'm trapped in HTML!
Pseudo-HTML, actually. A kind soul has gathered together this fine
resource to help victims, more of whom we can expect to see every day:
http://expita.com/nomime.html
| It's some kind of divine punishment for reading newsgroups in
| Netscape and not Gnus.
Or any competent newsreader (browser add-ons don't qualify):-)
Drew McDermott <··············@yale.edu> writes:
> Help! I'm trapped in HTML! It's some kind of divine punishment for
> reading newsgroups in Netscape and not Gnus.
one alternative is to sign up with google and post from there;
the interface is simple, but threaded and more or less usable.
your posts will not get wrapped in html or other junk.
oz
--
you take a banana, you get a lunar landscape. -- j. van wijk
From: Eduardo Muñoz
Subject: Re: How do you organize your source code?
Date:
Message-ID: <usn55vuyi.fsf@jet.es>
Drew McDermott <··············@yale.edu> writes:
> Help! I'm trapped in HTML! It's some kind of divine punishment for
> reading newsgroups in Netscape and not Gnus.
You bet.
This message is fine but just because of the
mention to Gnus :)
--
Eduardo Mu�oz
In article <·················@yale.edu>, Drew McDermott wrote:
><p>Directory structure is not very important, and implementation isn't
> important either, except that different vendors have different 'defsystem's,
> so the tendency is to use the portable Kantrowitz defsystem if you want
> implementation-independence.
What is Kantrowitz defsystem?
--
Gisle S�lensminde ( ·····@ii.uib.no )
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going
to land, and it could be dangerous sitting under them as they fly
overhead. (from RFC 1925)
Gisle S�lensminde <·····@apal.ii.uib.no> writes:
> In article <·················@yale.edu>, Drew McDermott wrote:
> ><p>Directory structure is not very important, and implementation isn't
> > important either, except that different vendors have different 'defsystem's,
> > so the tendency is to use the portable Kantrowitz defsystem if you want
> > implementation-independence.
>
> What is Kantrowitz defsystem?
MK:DEFSYSTEM. You can find it in the CLOCC
http://sourceforge.net/projects/clocc/
there is a very recent file release for version 3.2 interim.
If you want you can access the CVS modules directly. The module for
version 3.x is 'defsystem-3.x'. If you are brave, check out the new
version 4.x: the CVS module is 'defsystem-4.x'.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.