Slashdot Mirror
RMS The Coder
Andrew G. Feinberg writes "Here is a article on the LinuxCare website. " This is a cool interview just because its not dealing with the usual GNU/Open Source/Free Software stuff, but more with code, coding, and lots of other stuff that frankly just isn't political. Enjoy it.
That does sound like a really cool application for LISP, and one where it does make a lot of sense. Now that the ol' memory has been engaged, I have been thinking back to a programming languages class I took a long time ago. We ended up writing bits of a compiler in both C and LISP and I had forgotten how much easier it was to do a number of operations (like tokenizing and parsing) in LISP than in C. (Although part of me still thinks this may be because programming in LISP via EMACS is one of the most solid, easy to use, and just well integrated programming envrionments ever put together. Hmm... I wonder if RMS did that on purpose :) )
DrLunch.com The site that tells you what's for lunch!
This is a very nice talk showing for once, not :)
just the political ideas of Richard Stallman, but
why he deserves so much respect whatever his
positions are: his incredible programming skills.
I really believe he's one of the great minds of
our time. Heck, gcc, emacs, POSIX, what else
gcc sources are a good example. I don't know if he's the one that came up with the idea of compiling to an intermediate form and then having each cpu target translate the intermediate, prepackaged form to machine code, but that's a fabulous idea.
Yet another person who put an easter egg in a C compiler; the other one (putting both a (harmless) backdoor in his C compiler, and code in the compiler that would detect unmodified C compiler sources and insert the hack as the compiler was built) was more creative though.
ROTFL! The irony of this that is that RMS makes a big deal in this article about how he's been so busy getting the BSD license changed so that you don't need to mention contributors, but he then keeps making such a big deal about having GNU mentioned in the context of linux. He's so rigidly idealogical that it is deliciously funny to catch him even slightly hypocritical.
Having had the laugh, though, I would point out that it could still be considered in good taste to mention GNU or FSF given the magnitude of their contribution. Think how upsetting it would be if MS made a distribution and called it "Windows 2001", which they apparently could if they wanted. Yikes!
Not exactly - the open(2) man page on my machine says that O_SHLOCK and O_EXLOCK give you locks "with flock(2) semantics", but the flock(2) man page says that they're advisory locks. The "deny {read,write,read+write}" locks on DOS and Windows are mandatory locks - if you deny read access, nobody can open the file for reading, period (I'm not certain whether even privileged users can override that), and if you deny write access, nobody can open the file for writing, period.
And Perl is certainly strongly typed--providing you look at it the right way. You could say that Perl has strong typing but late binding, that is, dynamic typing.
Let me explain. If you store an object of type Foo in variable $ob, you are perfectly welcome to store an object of type Bar there later. This is very polymorphic. However, due to dynamic typing, if you call a method that only works for class Foo when the variable is holding a Bar--or vice versa--then you'll take a run-time exception.
The use fields pragma affords you static typing, however, so that you'll get caught early, back at compile time, for certain kinds of incorrect OO operations; viz., improper data attribute access. Perl has a lot more compile-time analysis than you might be used in other so-called "(byte-code) interpreted" languages.
Perl also has sane conformance rules between certain fundamental kinds of values that confuse people. That's not to say it's not strongly typed (again, given the right kind of squinting). For example, using an integer where a float is called for has a particular and completely well defined rule that gets applied. However, using a float where a Foo object is called for certainly does not, and you get zapped with an exception at that point.
There are certainly things you can do if you prefer a less forgiving system. For example, you can promote numeric warnings into fatals within a particular lexical scope via use warnings FATAL => 'numeric'. Or you could use the new lint tool to find dubious context coercions, such as perl -MO=Lint,-context,-undefined-subs myperlprogram.
Dynamic typing and certain common-place default conformance rules means you don't have to worry about a lot of busy-work if you won't want to. It also means you can detect whether an integer is odd using the peculiar $n =~ /[13579]$/. :-)
It's been a long known fact that RMS dislikes host/network security. Consider the following scenario that is not at all unlikely: Joe Hacker/Cracker/whatever doesn't like emacs very well--Joe is a vi God. He uses RMS's poor security setup to infiltrate gnu.org and silently patches the new version of emacs source that is supposed to be oh-so-cool. Hell, he might even do it in a very subtle way, i.e. in the LISP interpreter itself. The result is that after some predetermined amount of time, the home directories of the users go Poof! Hell, the trojan may have even sniffed the root password by then and then the entire system goes poof.
Remember every one of who runs a Linux system or other GNU-based system rely upon GNU to maintain our security. If some ankle-biter decides to screw with my system (good luck), I take the time it takes to recover quite personally. It's one thing to live a read-only life, but a read-write-world life is dangerous for us all.
Oh, and don't bother to point out that the source is open and so it can't happen. The Kerberos 4 source was open for years and years and it was trivially crackable in seconds, until Lodin, Dole discovered that they were using laughable random numbers.
Howard Owen hbo@egbok.com Everything's Gonna Be OK Consulting
"Even if you are on the right track, you'll get run over if you just sit there" - Will Rogers
Something like the Richter scale (in which an increase of 1 indicates that the earthquake was thirty times more powerful)?
;)
Let's call it the Stallman scale, then. RMS is a 10-Stallman; Theo is about an 8-Stallman, I would guess; Linus varies between a 3-Stallman and a 6-Stallman; Alan Cox is a 1-Stallman; Tom Christiansen is a 7-Stallman.
Logarithmic, of course, so RMS is about 100 times more difficult than Theo, and about 1000 million times more difficult than AC
As is common with interviews, it was most likely a transcript of a recorded conversation; the mistakes are those of the person who retyped it. (See the earlier comment about the error in RMS's statement regarding the #pragma hack.)
I forget who said it, but I recall once some OSS advocate saying he wished he could just ignore RMS and the GNU project and write them off as the radical wing, but that unfortuntely RMS had written far too much code to be ignored.
I think that's a great statement about how in the OSS/FS world your code does wind up being very much where your mouth is. The more code you write, the bigger say you get.
Personally I love the GNU project, and I am very glad that RMS has written so much code that he can't be ignored.
And "substantiate" should have been "instantiate".
LILO boot: linux init=/usr/bin/emacs
I have still failed to see the greatness of LISP. Since I prefer Emacs as editor I can do very simple things, such as editing my .emacs but not much more.
:)
OK, someone with experience with LISP and e.g. ML (or any other functional language), explain why RMS and others call LISP a superior language? When I studied CS we learned ML and I thought that was a brilliant language. Perl on the other hand is superior when it comes to manipulating text.
Funny, RMS came up with the POSIX name.
This confirms everything I've heard about RMS being argumentative. That guy will never compromise no matter what.
"Linuxcare: That's not unique to LISP though."
"Richard: Well, it is mostly unique to LISP."
"Linuxcare: Right, but you have to count the strings."
"Richard: No, you don't have to count strings."
"Richard: I couldn't block approval of the standard on those grounds, so instead... I posted a notice about the coup in which the evil repressive forces of POSIX....Then a slightly prudish board member convinced me to change it to POSIXLY_CORRECT which I now think was a mistake"
Richard: Do you know about the bug that depends upon the phase of the moon?
Linuxcare: I've heard about this.
Richard: We always liked to talk about the bugs that depended on the phase of the moon. So, when Guy Steele wrote the Rabbit compiler, which is a scheme compiler, he made it print out a comment at the beginning which showed the time it was compiled and so on, but it also put in the phase of the moon. So, you could always look. If you had a bug that depended on the phase of the moon, you could look at the thing and see at what phase of the moon it was compiled, and that might help you figure out what went wrong. Eventually, he got a bug report about a certain program that had been compiled once, and worked, and when it was compiled at another time it didn't work. So, he looked and he discovered that when the initial comments were printed out, the LISP feature that would automatically put in a line break if a line got too long was activated on one occasion, because the phase of the moon took too many characters to print out. So, it triggered that feature, and the last part of the phase of the moon was on another line, and therefore it wasn't marked by comments. So it was just sitting there in a file, whereas at another time the phase of the moon didn't take up so many characters, and the whole thing was properly commented. So, this was a bug that actually depended on the phase of the moon. You can take that as a final thought.
_____________________________________
From some experimentation, I'm pretty sure a basic perl filter ( s/<.*?>//g; ) is being run on our sigs now. This, frankly, just sucks. And I agree with you, if we had the damn code, poor, poor, CdrTaco wouldn't have to work his little fingers to the bone, and we might have a better solution.
<RANT> /., because usually they're basically whiny and annoying. But on this point, I have to be a critic myself. This is a site which is built on free software, and which claims to be one of the biggest media voices for free software, and yet, as far as I can tell, the software that runs /. is non-free! Good intentions don't count here, Rob-- the code is being kept hidden from us. We don't need a pretty tarball, for God's sake! Just set up a CVS server! I'll host it (cvs1.ompages.com)!! It's time this deplorable situation was changed.
I normally dismiss critics of
</RANT>
"Get away from my house you freak!"
-Neal Stephenson
There is no K5 cabal.
I am not the real rusty.
It was unbelievably cool. It was written in their own variant of MACLISP that they'd written, complete with a compiler that produced C code. Apparently the product is still available in some form from Microsoft (sigh), and I assume it's still written in LISP, so I would say that LISP is in fact a language that's used to develop commercial products.
This natural language interpreter could obviously have been written in C, but whether it could have been gotten to market in time to be of any use is entirely questionable. LISP's ability to manipulate strings of data (not strings of text) in a free and easy way is what enabled that application - without this, it would have been theoretically possible but not practically possible.
What you don't see much, and rightly so, is stuff written in LISP that would be better written in C. You also don't see a lot of programs that, while they would be easier to write in LISP than in C, aren't a lot easier to write in LISP than in C. IMHO, that's too bad, because it means that a lot of geeks that could benefit, as I did, from being exposed to LISP never have that opportunity.
libguile is under the GPL with an exception; "The exception is that, if you link the GUILE library with other files to produce an executable, this does not by itself cause the resulting executable to be covered by the GNU General Public License."
I think RMS is most thoughtful and most firm in his beliefs in the realm of software, and more generally utilitarian information (as opposed to expressive information). And it's in this very realm that he is most communist. I don't speak about economics in terms of who makes what profit -- I speak of an economics more fundamental. At the base of all economics is distribution. Who makes what, who gets what, how does it get there.
RMS wants us all to make software as we desire and need, and to give everything we have to everyone. It doesn't get there by any centralized organization, but by the trust in goodwill that makes it inevitable that when the first person gives the software away the chain will not be broken -- and it seldom is.
At least, that's what the GPL does, in spirit as in practice. And how could it be more communist? The GPL neither denies nor supports profit. But places the rights of the user (the masses) above the rights of the author (the capitalist). That sounds communist to me. But that doesn't have to be a bad thing.
Maybe RMS doesn't want the means of production to be placed exclusively in the hands of the people, or start a violent overthrow of the ruling class to make room for a dictatorship of the proletariat, but that's just one perspective on communism.
echo "blah" > #temporary_file#
mv #temporary_file# existing_file
There is your atomic supersede. It's in the atomic rename operation..
Probably not. Pascal compilers did that in the late 70s for machine portability. The Pascal code was compiled to an intermediary called P-code, which was then compiled to machine code by an architecture dependent piece.
The Pascal vendors billed this as a big breakthrough for portability at the time, but I'm sure that earlier examples could also be found.
RMS does, indeed, believe that most things should be open. He is not what one would call a personal privacy advocate. He wouldn't attack you for having your privacy (from what I've read of his thoughts), but he's not big on keeping everything you know and everything you have to yourself. He's not the world's biggest capitalist, that's for sure. :-)
..." model.
I agree with him on many points; I think the world would be a better place if we could trust each other. Mind you, I believe in security; but I believe in it as a trust model, not as an "exclude everyone but
That's why I use programs like portsentry, etc.
- Michael T. Babcock (Yes, I blog)
You couldn't run a program to do something such as tail -f if whoever was writing to the file opened it with a mode that prohibited other processes from opening the file for reading.
Programs aren't obliged to do that, but they might do that to prevent other programs from reading the file until they're done writing it (so that they don't get incomplete data - of course, the whole point of tail -f is that it should be able to read an incomplete file...).
I don't know whether fopen( file , "w"), say, opens with "deny read" on Windows; CreateFile(), as I remember, lets you specify the "share modes" as an argument, so you can deny read, deny write, deny read or write, or deny nothing to other processes. (CreateFile() is the Win32 equivalent of open(); instead of UNIX/POSIX, where you can create a new file with open(), you can open an existing file with CreateFile() in Win32.)
From reading the other posts, about RMS living as if the community is trustworthy, except when he's forced to do otherwise, because you should trust the community, etc... I got a different view of his beliefs.
Most people think of communism (discounting rabid people who think USSR == Communism) as sort of a global welfare state, where you can sit around and get by, or strive and strive and be held back.
But, if you had a mature community, this wouldn't happen. The same as, in a mature society, like that which Stallman grew up in at MIT, where he could leave his email unpassworded and not lose it.
In a mature society, you could leave your doors open, because everyone would be, if not rich, then at least, not poor. You could leave your email open because people wouldn't trash your machine just to prove a point.
I think RMS honestly lives by the golden rule, treat others as you would have them treat you. He wants open code, so he opens his code. He doesn't want nasty controlling laws, so he promotes ways around these laws, GPG for example.
I'm not saying he's Jesus or anything, but he seems to have decided on what he feels he has to do to live a moral life, and he's doing it, with few contradictions. To see this, you just need to see what his goals are.
The GPL is basically a 'place' to put code you think will benefit people. You have to have written the code, or have it already given to the free world, such as with a BSD or public domain license.
If someone can't make a living because all the code they'd write exists in better form under the GPL, then perhaps they don't deserve to make a living as a programmer.
And the GPL doesn't even prevent you from making money, it just means you need to sell yourself as a glue programmer, and a systems integrator, instead of just a programmer.
Anyone can sell GPLed code, and charge to set it up, they just can't slap their own copyright on it. And for everyone except those with an irrational need to own everything, this is enough.
When people whine about the GPL, all they show is that they can't get by without stealing code, and they don't want to be forced to show this.
LISP is really nice when you're pushing the state of the art. It's a simple, flexible core with lots of hooks for extensions. I once heard it called "the programmable programming language". So if you're writing a big program, you can begin by extending LISP into a domain-specific language. You can even add new kinds of declarations and control contructs.
LISP is very pleasant for hacking if you learn to see past all the parentheses.
Eric Kidd <eric.kidd@pobox.com>
Sure, but Theo just maintains a distro of BSD and audits a bunch of code.
When he's written a whole C compiler from scratch, along with a goodly hunk of the OS support coded, then he'll be that much more 'difficult' but he's also have earned the right.
Alright, I like RMS and his teachings as much as anyone, and even agree with the sentiment of this statement. If standards aren't serving users in the best way possible, what good are they?
But if it were someone from Microsoft making this statement, let's admit it. We would be jumping all over their throats and making accusations about "embrace and extend". Obviously, since GNU makes free software, there's less worry about them subverting the standards process, but where do you draw the line?
BTW, the POSIX_ME_HARDER part was hilarious. Made my morning. :)
I noticed your signature. Actually, Slashdot sigs are still interpreted as HTML. It's just that whenever you edit your user preferences the tags are somehow lost, and you end up with unformatted text in the text box for your sig.
The solution is to go back and re-insert the tags every time you edit your preferences. It's annoying, but it works. (See my signature. ;) )
This is a known Slashdot bug, and if I had the damn code I would fix it.
Vovida, OS VoIP
Beer recipe: free! #Source
Cold pints: $2 #Product
The road to hell ... is paved with good intentions.
Not entirely, I don't think. Besides, I doubt the road to heaven has anything to do with money.
One thing that surprised me most about the interview was what he said about security and how he doesn't like it. Did I interpret this correctly? Does he really think everything should be open? Maybe I'm missing something..
Is there anyone more familiar with his position who would like to fill me (and others) in?
Richard: the C specification which said #pragma was supposed to do something about implementation design.
I'm sure this is a misquote. I'm sure that what he actuially said was: the C specification said #pragma was supposed to do something that was implementation defined.
What that version of the C compiler did was, if it processed a #pragma, it did something implementation defined all right: it exec()ed Rogue.
Imagine: you're compiling an innocent C program, that happens to have a #pragma line on it, and suddenly the compile is gone, and your screen is running Rogue!
Vovida, OS VoIP
Beer recipe: free! #Source
Cold pints: $2 #Product
Quite the technical article, very informative...
Gives whole new meaning to the phrase "Talking with a lisp."
Thorry, I'll thut up now...
No thanks. I don't smoke anymore.
Hail Richard, bereft of social grace.
The fnord is with thee.
Blessed art thou amongst antibusinessmen,
And blessed is the fruit of thy doom, the GPV.
Holy Richard, lover of poverty,
Pray for us coders now,
And at the hour of disemployment.
I do care to look. I just don't know what Lisp has to offer from the software engineering point of view that you need in large projects - interfaces and modules, hiding implementation details, strong typing etc. The stuff you find in languages like Ada... It seems that Lisp is great for smaller applications, but I can't really judge it, that's why I mentioned that I've never seen anything bigger than 50 lines. Not to prove anything! ;-) Maybe you have a link...
People are always asking "What if Linus got run over by a bus" -- or Alan Cox, or Guido or Larry or even (shudder) ESR.
Most of these people are expendable. Great guys, sure (ESR I reserve judgement on. Sorry. The guns scare me. British.), great guys whos projects will live on thanks to the licences under which they've placed their work, and the openness of the systems they have produced.
RMS, however, is a different matter. He's coded some great stuff, (I'm not an EMACSer myself, mind you) but as the interview states, he's moving into a more managerial role because he has the drive and the conviction to push for libre software. Plenty of people can code -- the FSF employs some of them. Very few people can campaign like RMS can -- and fewer still share his convictions. ESR won't do -- he doesn't feel the same way about freedom of software, he cares more about the bazaar than about the freedom.
SO: what *if* RMS got run over by a bus tomorrow? We need some fault tolerance here.
--
Another thing that RMS did that was really incredibly cool was he worked out how Ada could behave itself just like other computer languages rather than being really quite fierce and hostile. When he helped a bit in the initial design of GNAT (the GNU Ada compiler) RMS worked out that the Ada "library" that is required by the standard could in fact be a lightweight definition consisting of little more than the source code with attached timestamps, and some little supplementary text files, rather than the previous system. In this way GNAT was made a true first class language front-end for GCC without making GCC jump through any hoops or do anything really pointless.
Before GNAT, Ada "libraries" were these monstrous opaque creations that made compilation incredibly slow - the compiler would have to open each library and read the (huge, expanded) semantic information associated with each separate unit mentioned in the current compilation from disk, rather than just going and getting the source code. By the early 90s the old Ada library approach was total junk, as GNAT easily blew away all previous Ada technologies using a combination of a) one of the worlds fastest language parsers (I would guess, certainly the fastest Ada parser ever seen) b) bountiful cpu power and RAM, and c) RMS's new lightweight library design.
These days there is a small but happy free Ada software crowd building up around GNAT, and I believe the GNAT team has been able to contribute a fair amount of value back to the GCC core. RMS helped to make this all possible and vastly improved the lot of a number of underpaid overworked Ada programmers (defence, telecoms, transport infrastructure etc).
If you want to try that at home,
try
cat file > file
and boom.
I'm sometimes bitten by that when filtering files with grep an mistyping the second filename.
Yes, the "Cuckoo's Egg" crack was accomplished through movemail and moving a patched kernel over the original. However, this could only be done if emacs was setuid root, which is Bloody Stupid in any case. So don't go blaming Emacs. :)
You know if you really did something like that you should have read the liscence first. Gee I certainly not break the bank on someone elses work and get that close to the fire.
There are usually a couple of people who use the little corruption of the GPL "GPV" and I am guessing you are one of the ones that do except you post anonymously.
If it weren't for programs written under the GPL most likely I wold have to have sprung for a totally new computer because of instability and bloat in my software at least 10 times since I first got my first one some years ago.
There was a really good reason why Stallman decided to write these things: because the ones that they had when he was around were too damn expensive and slow for development purposes and security parameters.
I saw a paper on the internet from about oh 1994-95 or thereabouts when linux was just getting off the ground as a viable OS for at least a few people. It discused reliability of unix commad line utilities. Guess what most of the commercial distributions of unix had at least one if not more major utilities that failed their tests. Not only that but because of him we also have unix on PCs for which I am eternially grateful for someone thinking of so that it could really work.
Slashdot social engineering at it's finest
I'm not sure it will work in a large-scale project.
Well, much of Emacs is (as far as I know..) written in Lisp. Is that large-scale enough for you?
There's also Sawmill, which is a window-manager written mostly in Lisp, with C for the lowlevel routines.
Daniel
Hurry up and jump on the individualist bandwagon!
This is a correct version of the above post... call it "oops". :)
/What/ this linked list represents doesn't matter except to the interpreter; it's a list like any other. Applying the car operation to this list would yield the symbol 'map; the cadr (first rest) operation would yield the list '(lambda (l) (car l)).
,nwod eno ekaT"^
Generally speaking, Lisp is superior because it's made out of lists. This is much more important than it looks. Why?
(WARNING: here there be dragons! Below I simplify extremely for the sake of understanding. Please don't bash! Also, note that everything I say about Lisp interpreters also applies to Lisp compilers.)
Take Perl, for example. In Perl, programs are basically one-dimensional character strings, usually read from a file. What the Perl compiler does (either when called to run a program, or an eval() or a s///e) is take that string and parse it into a syntax tree, which is then 'flattened out' into bytecode, which is, in turn, executed by the bytecode interpreter.
In Lisp, on the other hand, programs and data are naturally represented as lists; the strings that you type into the Lisp top-level are parsed into lists as soon as possible (an extremely simple thing to do, by the way), and from that point on the entire environment can use a homoiconic set of primitives (car, cdr, cons, eval, etc.) to handle any data that you may pass to it.
Exempli gratia, let's look at two functionally equivalent programs (defining a program as a representation in computationally concrete form of an abstract mathematical algorithm):
# Perl
map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map { [$_, $f->($_)] } @ARGV;
; bastardized Scheme
(map (lambda (l) (car l))
(sort (lambda (a b) (<=> (cdr a) (cdr b)))
(map (lambda (e) (cons e (f e))))
*argv*))
You may have recognized the Perl program as a variation of the famous Schwartzian transform, wherein $f can be any key-producing function; with $f = \&-s it becomes a program that orders the filenames passed as arguments by size. The below program is not quite valid R5RS Scheme; the *argv* list, equivalent to @ARGV, is not standard, and the <=> form can be easily defined in terms of the comparison operators:
(define (<=> a b)
(cond
((> a b) 1)
((= a b) 0)
((< a b) -1)))
Likewise, with a bit of creativity, the sort form can also be implemented.
Anyway, how does all this matter? Simple. As data, the Perl program is a 74-element character array; it has all kinds of special symbols and tokens, and turns out to be horribly complex to parse. On the other hand, as data, the Scheme program is very simple: it's a linked list with three elements, one of which is the symbol 'map, and two of which are sub-lists.
It's important to note here that the interpreter is a function like any other; as such, it deals with lists like the ones above. The reader - which parses text into lists - is a separate system.
Originally, the fact that all Lisp programs are lists was considered a huge disadvantage (even by John McCarthy himself), and for years there were attempts to introduce a new Algol-like syntax (called M-expressions) to supersede the list representation (called S-expressions). But, as it turned out, this turned out to be a huge advantage, and Lisp programmers almost universally appreciate SEXP.
Of course, there are many other reasons why Lisp is a superior language, although many of those are implementation-dependent and may also be present in other languages. But having a homoiconic representation for programs and data is by far the greatest advantage.
Note: While we're on the topic of languages with homoiconic representations, I thought I should mention Funges, a family of languages in which programs are represented as n-dimensional, potentially infinite cell-spaces to be traversed by an instruction pointer; each instruction occupies one cell. The written representation of Funge programs follows this; for instance, in Befunge (the 2-dimensional Funge), a typical program might look like
v
>v"Hello world!"0<
,:
^_25*,@
or even better,
9::*\2*+00p0v"."0<
>310p0"," >"llaw eht no "v >#v_ ^
^_210p0"--:" v ,
: v " of beer" < :
- >"selttob"00g.^ < <
1 >00g1-#^_$" elttob erom enO" ^
>00g#^_$" selttob erom oN" ^
^_110p0",dnuora ti ssap
^:-1_010p00g1-00pvv:-1g01_@#g00,*25<
^ <
To the editors: your English is as bad as your Perl. Please go back to grade school.
It's been a while that I learned the basics of Scheme - what impressed me was lazy evaluation, which enables working on lists whose arguments are created when they're needed. I can't explain it any better, but it seemed a very nice feature.
;-) I'm not sure it will work in a large-scale project.
However, I don't think that Lisp is superior to other languages. I've never seen or written anything with more than 50 lines of code. You can do nifty things, but I'm not sure for which kinds of applications Lisp is best - it can't be good for _anything_
All programming languages are equally powerful in a Turing sense, since you can implement an interpreter for anything you like within almost any of them, more or less. However, that doesn't mean that they are all equally powerful in practice, because many languages expressly forbid you from doing things that you might wish to do. RMS was referring to the "natural" power of a language when talking about LISP, which could be defined as the set of everything you can do natively within the normal constraints of a language, ie. without creating a nested interpreter and without bypassing the goals of its designers.
LISP is incredibly powerful using that definition, because it is simultaneously an extremely high level language while giving you access to both very low-level data and very high level abstractions, all handled together uniformly at will. And of course, code is just data, adding yet more flexibility. You just can't beat it in the power area.
However, for most people it's the wrong language to use -- horses for courses. While scalpels and atomic bombs are very effective in their respective areas of application, most cutting and demolition uses alternative solutions, and you don't give these nor any other extreme power tool to your kids as toys.
Tucked away behind the scenes though, LISP is the ideal extension language, offering the inherent power that is needed for an unknowable future. Guile will serve us well there.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
tupelos should have been: tuples
Symbolix should have been: Symbolics
address base should have been: address space
I would suggest proofreading before publishing. (That said, it was an interesting interview.)
You use a linux distribution. So it still would be proper to say that the utils are linux utils. When you have an NT system and you use or create an application you say it's an NT app or such. The same applies to linux. A kernel dosn't make an OS.
Slashdot social engineering at it's finest
-----------
"You can't shake the Devil's hand and say you're only kidding."
Why don't you code a domain-aware, learning type assistant hooked into the eval dispatcher? It wouldn't be able to do strict checking a la ML (nor would you want it to), but when fed off a list of heuristics I bet that it could be made to catch a large variety of type-related mistakes that human programmers habitually make.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra