RMS The Coder 333
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.
Re:Commercial LISP (Score:2)
Re:Why is LISP superior? (Score:1)
you have to get infected to really grok w/ it. good luck!
--thi
Wish we'd have more articles like that. (Score:2)
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.
Linux? GNU Linux? Lignux? and BSD licensing (Score:2)
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!
Re:Ever Notice? (Score:1)
:)
(A joke! Laugh!)
Asynchronous Logging (Score:1)
This is referred to as asynchronous logging, and it can't be done on NT.
This is one of my chief nitpicks with that OS.
Re:Security (Score:1)
On the other hand, if you're trying to do something cooperative, such as writing or maintaining free software, it helps to cooperate! For instance, if somebody has a question about some free software, do you care who answers it as long as the answer is good? This idea applies to a lot of other areas, too.
I believe that RMS said that security makes sense in banks and in the military, but makes less sense in the lab. This isn't unreasonable, since presumably people working together in a lab share some sort of common goal.
Re:Asynchronous Logging (Score:2)
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.
Re:YART - Yet Another RMS Triumph (Score:1)
You're right of course, I just wanted to post like a jerk JUST LIKE YOU. Why? Because:
Your people skills are obviously superior.
You are never wrong.
If you were wrong, you would want someone to be as sarcastic as possible pointing out your mistake instead of pretending to be human and merely correcting you.
Re:Perl (Score:2)
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]$/. :-)
Re:Security (Score:2)
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.
Yikes! (Score:2)
Howard Owen hbo@egbok.com Everything's Gonna Be OK Consulting
Why I never learnt LISP (Score:1)
Re:Idea: Bring RMS and Theo de Raadt together! (Score:2)
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
Re:english translation of the interview (Score:2)
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.)
atomic supersede blows (Score:1)
Ahh the benefits of a traditional computer science education, where you can sit around and dis terms like "atomic supersede"
Re:Write a type assitant! (Score:1)
Actually I was already thinking about a "type assistant" that can also do a lot more by attaching not only types but also properties (like: this number never gets greater than n) to variables and have some automated deduction system with some clever heuristics help you show that your code does what it's supposed to do.
But I'll have to finish my PhD first...
RMS wrote too much code :-) (Score:4)
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.
Re:Write a type assitant! (Score:1)
I'm not sure exactly what you mean by "domain-aware, learning type assistant" but CL compilers that check types are out there already
The compiler in CMUCL (called Python, but not to be confused with the language of that name), for example, has a very nice type inferencer in it already, and when you set your compilation settings appropriately will even warn you where it hasn't been able to infer things so you know what explicit declarations to add
See the appropriate bit of the CMUCL User Manual [mindspring.com]
(with-gratuitous-plug
Re:Wish we'd have more articles like that. (Score:1)
Re:english translation of the interview (Score:2)
Why is LISP superior? (Score:3)
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.
Re:Why is LISP superior? (Score:1)
Out of curiosity, why do you like Common Lisp over Scheme? I haven't actually used Common Lisp, but I've used a few other Lisp variants including Scheme. Scheme seemed to be the "nicest" of all the ones I tried.
Re:RMS wrote too much code :-) (Score:1)
Definately a man who deserves his say.
RMS argumentative (Score:2)
"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"
Re:Why is LISP superior? (Score:1)
What I found funny was the part of the article where the interviewers figured they could argue with RMS... that Perl was better than Lisp no less. While I'm not completely sure I agree, especially since I use neither language anymore, I don't think I would be silly enough to argue with him [RMS].
-dr
It's funny, laugh (Score:2)
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.
_____________________________________
Re:Why is LISP superior? (Score:1)
If anyone's interested in the project I was talking about check this site [uni-muenchen.de].
I usually ran it in Emacs using LMUScheme [uni-muenchen.de], a small and fast GPL'd Scheme implementation that hardly anyone seems to know.
Re:RMS wrote too much code :-) (Score:1)
*Doesnt it remind you of Slashdot bitching about Sun not giving credit to the Blackdown Team for the Linux JDK? The license let Sun call it whatever they want.*
Of course RMS knows the license lets them call it whatever they want to call it. He created the license, after all. He, like a lot of people, finds fair to call the whole system GNU/Linux.
Re:Why is LISP superior? (Score:2)
Re:RMS wrote too much code :-) (Score:1)
have the more say you get. Talk is cheap..let see some cash.
Having lots of cash means you're working hard for yourself. We should other people be impressed by that?
--
Re:RMS wrote too much code :-) (Score:3)
Prior to that, K & R were famous, and prior to them, Knuth. Yep, they all wrote code and in some senses gave it away, but it was the ideas embodied in the code that they were giving away that make them famous. Linus is famous for the "just do it/can do" nature of his work, unlike all the bigger named, more experienced coders and architects who didn't deliver their kernel work to the mass of people who had x86s sitting in front of them.
Re:YART - Yet Another RMS Triumph (Score:1)
Appliances (Score:1)
He's still kickarse cool though.
Re:Standards (somewhat OFF-TOPIC) (Score:2)
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
Re:Why is LISP superior? (Score:1)
Does this translate into any improvement in the size of the compiled code? Having short snippets of uncompiled code is nice, but if it doesn't translate into some kind of savings in actual code size, I dislike giving up 'a little speed'.
"God does not play dice with the universe." -Albert Einstein
Commercial LISP (Score:2)
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.
Re:RMS argumentative (Score:1)
Re:Give the man a break ok? (Score:1)
Would the BSD sources have been freed at all if it wasn't for Richard's nagging of the Berkeley people.
And yes, Solaris does exist on the x86, but who in there right mind would go do such a thing.
So, it may not have been RMS personally writing/porting Unix to the PC but if it wasn't for him, how many of us would be stuck using the crud M$ is selling???
What license does Guile have? (Score:1)
Re:What license does Guile have? (Score:2)
Re:Ever Notice? (Score:1)
Re:Security (Score:2)
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.
atomic supersede is called rename(). (Score:2)
mv #temporary_file# existing_file
There is your atomic supersede. It's in the atomic rename operation..
Re:Why is LISP superior? (Score:2)
Re:RMS argumentative (Score:2)
... many arguments don't help either person get a better grasp of things at all. You'll notice that RMS wasn't getting a better grasp of things, just reinforcing his point of view.
Pascal had an intermediary form before gcc (Score:2)
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.
Re:Security (Score:2)
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.
Re:english translation of the interview (Score:1)
Re:Asynchronous Logging (Score:2)
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.)
Re:Security (Score:2)
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.
Re:Security (Score:2)
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.
Good Points of LISP (Score:2)
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>
Re:atomic supersede is called rename(). (Score:2)
First, if you don't own the file, the new file will be owned by you, and if you're not root, there's nothing you can do about that.
Second, it generally doesn't do what you want when there are more than one hard link to the file.
I think an atomic supersede would be a useful facility to have. It probably wouldn't be that hard to implement either.
Re:Idea: Bring RMS and Theo de Raadt together! (Score:2)
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.
Standards (Score:4)
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. :)
Re:RMS wrote too much code :-) (Score:2)
Giving away money is easy (if you have it), giving up the chance to have money is harder. RMS is not a rich man. He could have been, if he'd ignored his ideals and applied himself to the pursuit of money -- if he'd taken money from Lucid, he'd have made a start on his fortune.
Why must I take the (flame) bait, so?
--
Re:RMS wrote too much code :-) (Score:2)
But your reasoning depends on whether we are talking about one operating system or many different operating system. Your reasoning assumes the later. That Red Hat Linux is different enough from Debian GNU/Linux, and Debian GNU/Linux is different enough from SuSe Linux. This means we shouldn't call any of them Linux either. It is either Red Hat Linux or simply Red Hat. But if the above operating systems are not different enough to be considered separate then we need a generic name that is the superset of Red Hat Linux, Debian GNU/Linux and SuSe Linux. So we are back to the GNU/Linux vs Linux debate.
One other thing. I have heard many reasonings why the OS shouldn't be called GNU/Linux (including the GNU/BSD/X/MyMom/Linux argument) but I haven't found any good reason's it should be called just Linux. Of all the components on a typical Linux-based system, why just Linux? And please don't tell me we should call it just Linux because everyone else does.
Re:Standards (somewhat OFF-TOPIC) (Score:2)
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
Re:The road to hell ... (Score:2)
Not entirely, I don't think. Besides, I doubt the road to heaven has anything to do with money.
Re:Standards (Score:5)
I think you draw the line exactly at the question: "Is the 'extension' closed and proprietary?" That is, when M$ extends a standard, you are not allowed to see what they did. If M$ adds extensions to HTML, they do it because it distinguishes their browser from Netscape. Now, maybe the extension is useful and good, but the fact that it may only be implemented by M$ browsers is, overall, bad for users.
On the other hand, when an author of OSS extends a standard, the code is open, and others may see and reimplement exatly the same functionality in their code as well. Assuming this extension is also good for users, then everyone can implement it, and the net result is a big win, rather than a hideous swamp of incompatibility (like present-day HTML).
"Get away from my house you freak!"
-Neal Stephenson
Re:RMS wrote too much code :-) (Score:2)
No, he probably DOESN'T mean that. If he did, he'd have said so.
Prefer what you'd like, but don't waste everybody else's time and bandwidth etc. bitching about what others prefer.
Security (Score:2)
Is there anyone more familiar with his position who would like to fill me (and others) in?
Interview spoiled #prgma joke. Here it is: (Score:3)
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!
Re:Security (Score:2)
In it, he proposes that those taxes should go to the recording artists based on polls to determine popularity. That suggests "To each according to his ability" rather than need. In other words, it encourages doing something useful rather than being needy as communism does.
In the context of Free Software, his philosophies apply to the distribution of information, not of material things, which communism concerns itself with.
Regarding economics, Free Software specifically allows itself to be sold with the profits completely retained by the seller. Something I would consider more compatible with marxist ideals would be more along the lines of "Free for non-commercial use" and "Pay x% of your profits if you're making money with this. We'll make sure it gets to a needy person".
Also, rms' philosophy on copyright and patents is completely within the bounds described by Thomas Jefferson, who predated the idea of communism.
Quoth Mr. Jefferson:
Another insightful article (by rms) about why he is the way he is:http://www.linuxworl d.com/linuxworld/lw-1999-11/lw-11-rms.html [linuxworld.com]
Re:Security (Score:5)
I support RMS in this. I wish people would understand that security isn't always important.
Re:What license does Guile have? (Score:2)
Vovida, OS VoIP
Beer recipe: free! #Source
Cold pints: $2 #Product
Re:Why is LISP superior? (Score:5)
- LISP has a completely regular syntax (well, let's say Scheme, since there are some disgusting hacks in Common Lisp). PERL has a syntax from Hell.
- LISP does stupid stuff for you - for example, you don't have to keep track of garbage, as you do with C. Perl doesn't garbage collect either (AFAIK), but it does at least have automatic memory allocation.
- LISP has a very different typing model from either PERL or C - every object has the potential to have any possible type. Lists are first-class objects, so you don't have to write yet another stupid list traversal routine every time you want to make a list of things, and you can build trees out of lists. This turns out to be very powerful once you understand it, but it's a little hard to wrap your brain around at first.
Unfortunately, in order to really appreciate the power (and the shortcomings) of LISP, you have to learn it - I can't really make a point-for-point comparison here that would convince you of anything. And anybody who claims LISP is a panacea is wrong - it just makes a very different set of tradeoffs than PERL or C.I would suggest actuallty trying to write some code in raw Scheme, not emacs LISP, that does some sort of interesting data structure manipulation, preferably recursively. Maybe pick up a copy of SICP [fatbrain.com], The Little Schemer [fatbrain.com] or The Seasoned Schemer [fatbrain.com].
Re: Security (Score:2)
Technically speaking.... (Score:2)
Gives whole new meaning to the phrase "Talking with a lisp."
Thorry, I'll thut up now...
Hail Richard (Score:2)
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.
Re:Lazy evaluation (Score:2)
Re:RMS wrote too much code :-) (Score:2)
Point #1: There are hundreds of command-line utilities on a Linux system that were not written under the umbrella of the GNU project or the FSF, despite the fact that they are distributed with the GPL. So how the hell do you know if he meant a GNU command line utility or a Linux command line util?
Point #2: The GPL does not restrict the redistribution of GNU utilities, and does not require one to name a product which redistributes those utilites with a name that mentions GNU.
The overall Linux system is a product of the work of whoever puts it together, i.e. RedHat Linux. The code was written by hundreds of people, but it was put together in usable form by the wonderful people at Redhat. THEY are the ones that decide what their product is called, and they have chosen to call it RedHat Linux. Anything else you call it is simply wrong.
I made this point to RMS in an argument we had on the GNHLUG [gnhlug.org] mailing list, and he was unable to refute this point.
What if RMS got run over by a bus? (Score:2)
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.
--
Re:Why is LISP superior? (Score:2)
Anybody have any examples of problems that can be solved in LISP and no other language? Or is this just standard RMS hyperbole?
YART - Yet Another RMS Triumph (Score:4)
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).
atomic supersede (Score:2)
try
cat file > file
and boom.
I'm sometimes bitten by that when filtering files with grep an mistyping the second filename.
Re:movemail bug and Cuckoo's Egg (Score:2)
Re:Why is LISP superior? (Score:2)
I'm by no means a Lisp expert (I have more experience hacking C and Perl), but the more Lisp code I write, the more I begin to appreciate the language. I started learning Lisp when I started using EMACS, then for a while I was hacking in Scheme (the Programming Language Concepts class at my alma mater was taught by a fellow who received his degree from Indiana University), and now I am doing a lot of programming (in my Copious Free Time) in Common Lisp - and I must say that of the three, I like Common Lisp the best.
Here's a short list of the things *I* like in Lisp (whither EMACS Lisp, Common Lisp, Scheme, Dylan, etc.):
...and so forth. You can get a lot more information from the Association of Lisp Users [alu.org] web site (especially the pages Language Comparisons [alu.org] and What is Lisp? [alu.org]), or from the comp.lang.lisp [faqs.org] FAQ. Another good place to get more information is from David Lamkins' on-line book Successful Lisp [psg.com].
And if you have further questions on Lisp, feel free to send me an email or drop a note into comp.lang.lisp [lang.lisp].
HTH.
Rev. Dr. Xenophon Fenderson, the Carbon(d)ated, KSC, DEATH, SubGenius, mhm21x16
Re:Security (Score:3)
If you wish to disregard security, that's fine with me, as long as it's your home machine. On a multi-user machine, it seems very inconsiderate to other users, since maybe they don't want people reading their mail, and once a cracker has one account, he most likely has them all. Not to mention the people who administrate the machine - we have enough to deal with without getting broken into because one of our users used their login name for a password.
Kind of odd that RMS says "security sucks" (not a direct quote, of course, but that's what he seems to be saying), then actively promotes crypto and GnuPG. I guess his thinking is that people have the right to choose between privacy and openness, which seems reasonable.
Re:Why is LISP superior? (Score:2)
Re:Why is LISP superior? (Score:3)
(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)
((
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
or even better,
9::*\2*+00p0v"."0310p0"," >"llaw eht no "v >#v_ ^
^_210p0"--:" v ,
: v " of beer" "selttob"00g.^ 00g1-#^_$" elttob erom enO" ^
>00g#^_$" selttob erom oN" ^
^_110p0",dnuora ti ssap
^:-1_010p00g1-00pvv:-1g01_@#g00,*25
(The Befunge programs above are not
Re:Why is LISP superior? (Score:2)
(the most beautiful LISP dialect, IMHO) for three years,
so I'll try to answer your question FROM MY PERSPECTIVE (however,
others will probably state other advantages of LISP when asked!):
The thing I liked the most was how it allows you to manipulate code
very easily in two ways:
1 - due to LISP being a functional language, any procedure is an object,
which can be passed to other objects AND can be manipulated anytime,
for example combining two procedures into a new one:
(define (n-times f n)
(if (= n 1)
f
(lambda (x) ((n-times f (- n 1)) (f x)))))
defines the function "n-times" which takes a unary function f and a number
n and gives back a new function which applies f n-times to its argument.
Now, taken that the unary function "1+" adds one to its argument
(define (+ m n) ((n-times 1+ m) n))
defines the function "+" with the obvious meaning (on integers),
(define (* m n) ((n-times (lambda (x) (+ m x)) n) 0))
defines "*" and so on
(OK, the example is artificial and the defined versions of + and * are
horridly inefficient, but real-world examples would be too long, so all
examples here will be artificial)
With this mechanism, you can build large customized procedures from atomic
ones. What you can't do is
a. always use certain language constructs like "if" efficiently:
(if test (f x) (g x))
will only calculate either (f x) or (g x), which is what you'd expect,
but if you define the function "choose" like this
(define (choose m n) (if test m n))
and do
(choose (f x) (g x))
then both (f x) and (g x) will be calculated before "test" is tested.
This is not only inefficient, if f and g have side-effects, the behaviour
will be different from the first version!
b. look into an existing procedure and modify it...
2 - LISP source code itself is a data structure (i.e. a list) that can be
arbitrarily generated, manipulated and executed VERY EASILY.
We use these mechanisms heavily in our project. To give you a taste of
LISP at work, I'll try to sketch what we were able to do with them:
We've implemented so-called normalization for a subset of the SCHEME
language itself. Normalization could also be called partial evaluation or
execution: You calculate everything you can and leave the rest untouched.
For example, the normalized version of
(lambda (x) ((n-times f 3) x))
would be
(lambda (x) (f (f (f x))))
(get it?)
For this to work, all the functions and objects used in the code have to
be defined in a special way. If they are, you simply do an "eval" on
the program which you want to normalize (that is, you EXECUTE the program)
and, as a result, the program gives you back the normalized version of itself!
(Normalization includes ordinary execution: if the type of the program
executed is integer and all free variables are instantiated, then the
normalized program will be... an integer)
As I have said, the functions and objects have to be written in a special
way. But this is no problem, because we pre-defined certain functions
(like recursors) with which you can program almost anything you want
without having to worry about these complicated mechanisms hidden in the
pre-defined functions.
And if that's not enough, I've also written a (pretty short) program which
lets you write programs in a special form (as Term Rewrite Systems, if anyone
knows what that is) and translates that into code that will work with the
normalization mechanism.
And if all that doesn't make your head buzz yet, here's how we USE the normalization
technique: We represent mathematical proofs as such normalizable programs.
Then we execute them and automatically get a normalized version of the proof,
in which all detours are removed. And then, we can calculate from this proof
another program which does what the proof shows it is possible to do.
And that program cannot possibly contain a bug because it stems from a
mathematical proof.....
Now you will say: OKOKOK, LISP has some nice features, but who, apart from
some freaked-out researchers, needs them?
Well, at first glance, hardly anyone. But only at first glance. Once you
got used to working with these mechanisms, you find lots of places where
they would be terribly useful as well (although not indispensable
as in our case).
One more thing: RMS mentions another advantage, namely the fact that LISP
is untyped (or, more precisely, dynamically typed), so that everything is
a list (basically). Well, this is an advantage in flexibility, but also a
disadvantage in debugging. When you've worked with LISP for a long time
and then do C++, for example, you notice that type-checking sometimes is
terribly useful.
I don't know much about ML, but AFAIK it is very similar to LISP, but typed.
All I know is that we couldn't easily port our stuff to ML, because its
type system (although it's more powerful than the one of most other languages)
is too strict for us, that is, we can't express, for example, the types of
our recursors in ML. So, in this case the untyped nature of LISP is
an advantage, but sometimes I really miss type-checking when doing LISP.
Give the man a break ok? (Score:2)
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.
Re:Lazy evaluation (Score:2)
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
BAD Slashdot! BAD Slashdot! (Score:2)
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<
^ <
Re:Why is LISP superior? (Score:3)
Everything is a list. Program code and data is a list. All commands (like compiling ) is issued in the form of a list.
So, you can do something like writing code, which when executed, generates code.
Additionally, lisp is typeless. A variable can contain lists, nested in lists etc etc... which can be code..
I programmed a Qt signal/slot system in 2 pages of code. Although syntax appears difficult when coming from the C++ world, I guarantee that template and pointer syntax is MUCH more difficult.
Here is some code, that when executes, generates a
method on the fly, which can then be executed in the future. ( i.e. C++ does NOT give us the ability to change the basic structure a class (add or take away methods or data members at run time)..lisp does.
Additionally, Lisp or CLOS has no problem dealing with multiple inheritance. Methods are not owned by a class like in C++ or Java. For example, a method (or in lisp, a generic function) can be specialized to run with more than one object (multimethods). i.e. method( class1 type, class2 type
Methods can even be specialized to run with a particular INSTANCE of a class. i.e.
here are 2 methods
method( instantiated object 1 of class A only ).
method( instantiated object 2 of class A only)
here is a method which when executed, creates a method which only works with a specific instance of an object. Of course this function is a list, and could be transmitted across a network, and executed !!
(defmethod map-signal((_container container) mapped-signal-name
(_transmitter transmitter-reciever) _transmitter-signal-name)
(let ((y (gensym)))
(eval`(defmethod
(broadcast _container ',mapped-signal-name data )))
(connect _transmitter _transmitter-signal-name _container y)))
Modern lisps (like Franz) are compiled into machine code, and can be VERY fast. Not as fast as raw C or C++, but the bottom line is programs that are 100 pages of code in C/C++ may be 1/10th
the size in Lisp, and exceedingly hard to do - or next to impossible - without writing a lisp -like system. So you can prototype huge systems VERY quickly, and then if you'd like, write some of the lisp code in C for speed improvements.
Dave
Re:YART - Yet Another RMS Triumph (Score:2)
Lazy evaluation (Score:2)
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_
Re:Why is LISP superior? (Score:3)
Think of C: it has ints, floats, chars, structs, and vectors of those things, and pointers to any of those things (maybe I left out a few, but you get the idea). Then, totally separately, it has code for manipulating those "data" things.
C++ came along and it added some ways to connect your data to the appropriate code so you wouldn't mistakenly point the wrong code at the wrong data. But getting everyone to switch to C++ was a grueling 10 years because of all the training, and reprogramming it took, and it didn't really resulting in a more satisfying coding experience.
Turns out folks weren't satisfied, though, and now we've got Java, which restricted a lot of things you could do toward the end of making some other things easier. We've just started the grueling 10 years for this one, and I suspect some of the stuff that got restricted (essentially, they grabbed the ++ and chucked out the C) is stuff that a lot of folks want to keep doing...
Anyway, back to LISP: it was said earlier that LISP syntax was regular, but while true, that didn't capture what else is true: the textual representation of LISP is simple and regular, yes, but after it gets parsed it is also stored in memory in a simple and regular way: LISP looks at the world as "things" (like C's ints or floats) and lists of things, including other lists. Your program is just a list of things, and your program is "visible" to you as data, very simple data.
In C, it would be as if the entry point to your program was main(argc, argv, argp) where "argp" was a pointer to your program itself: "main(argc, argv, argp)..." Not a string that starts "main(...", but something more like an array of all of your tokens. The variables in your program would be references to your actualvariables (haven't you ever wished in a C program to have access to the symbol table that the compiler created and threw away? in LISP you do) But even beyond this, if you went deeper into your program, when you get to the token "for" (at the beginning of your for-loop), you could look up the code that implements "for" and see what its code does. Don't like what it does? Write your own version that behaves differently... that's been done many times in LISP so that today, loops are really functional.
Now, I'm not saying that everybody should rewrite how "for" works, or that all programs should manipulate code. But, one way to see how powerful LISP is is to see that LISP in its lifetime (since 1960) has made transitions similar to C to C++ to Java, but those transistions were made within the language itself, by people experimenting with new ideas to see which caught on. LISP erases the distinction between code and data in a really meaningful and powerful way.
So, that's just one powerful thing about LISP. I guess the other major one I'd mention is that the programming tricks and idioms that you learn (just like you learned to "for(p=x;*p;p++)" your way through C arrays) remain more universal and stable in LISP. "Walking" the LISP trees of data has remained the same from 1960 your first day learning the language to now. The "toolkit in your mind" that you carry with you does not have to constantly learn a zillion new things. It's as if you went to look at the implementation of a Java class and thought, "oh I see, it does something simple" rather than, "oh, looks like I need to go digest a bunch of other classes that this one has inherited from."
Hope this is useful... and I didn't even get to tail-recursion which is so cool that it blows all of this stuff away.
Re:Why is LISP superior? (Score:3)
LISP is one of things you have to experience
to appreciate. My first reaction was "This
language wasn't invented...it was found crashed
in some dessert in New Mexico."
familiar you get with LISP the more you start
to appreciate it. It's a pretty radical departure
from Algol-like lgs. tho.
As for learning how to use emacs...the route
most people recommend is to run the tutorial.
Frankly, I think that is the worst approach. You
have a chicken or the egg problem because you
have to know some emacs to even navigate the
tutorial. My advice is to buy the printed Emacs
manual from FSF. I read a few chapters of the book
before sitting down at the 'puter to get
finger memory. It was much easier to learn this
way. The keystrokes in emacs are actually pretty
well thought out(IMO) but most people don't take
the time to get the ideas. They just sit down and
want to immediately start using it. Doesn't work
that way. Once you learn tho...emacs is just
great.
The natural power of a programming language (Score:2)
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.
Re:RMS wrote too much code :-) (Score:2)
The most important point I'm trying to get across is, the end product is still YOUR product, and you have the right to call it whatever you want (so long as it doesn't infringe someone else's trade mark, of course).
If I put together my own Linux distribution, I could call it Carnage Linux, Carnage GNU/Linux, Skatanafas, Joe's computer pizza, or whatever else I want to call it. Nothing in the GPL, restricts me from doing so. Whatever I chose to call it, if you called it by some other name, you would simply be WRONG.
Let Stallman make his own distribution, then he can call it RMS GNU/Linux. Debian has chosen to adopt his naming convention, and their product is rightfully called Debian GNU/Linux. Others have not, and calling it so is misnaming it.
RMS's arguments are mainly centered around getting due credit for the work the FSF and GNU project did. No one disputes that they deserve credit. But he can't simply co-opt the name of a thing to suit his own purposes.
Incidentally, as part of that same argument on the GNHLUG mailing list, it was proposed by those who think like me that we get the various distributions to adopt some sort of "GNU Inside" -type endorsement to give GNU the credit it definitely deserves. Jon "maddog" Hall, president of LI and (recently) former chairperson (or "reluctant chairperson" as he prefers) of GNHLUG, was willing to take this to the distributions to make it happen, but it was not enough for RMS. He INSISTS that GNU/Linux is the proper name, and won't settle for anything else.
PLEASE, don't get the idea that I don't like RMS. I have nothing but respect for the man and the work that he's done. I appreciate his ideals (mostly) and all the effort he has put in to spread them. BUT, I think he's being a little pig-headed about this one issue. Especially when alternative (and IMHO more appropriate) means of giving credit are available, but rejected by him.
Re:Security (Score:2)
I don't think I could do this myself -- there are things that I want to keep to myself. And, if I felt I could stand up for all of my life and had no shame in anything I did, I wouldn't feel the need to hide anything and would have much less need for security.
I don't know if it could really work for all of society could either. Some people have a strong enough will to disagree fully in public, but I fear most people would feel that their only choice was conformity if we didn't have privacy.
It's a tantalizing idea, though... information egalitarianism and a certain blending of the person into the whole. Of course, that sentence itself would put many a person off of the idea right out. But somewhere in it, it's more about honesty than anything else -- we live in public and effect our world greatly, so shouldn't we be entirely honest about who we are?
I think RMS really is a communist, even though he strongly denies it. He's not authoritarian or fascist at all, though those are often confused with communism. But really -- "to each by his need, from each by his ability". I'd like to be communist, but it takes a lot to live up to such an ideal -- all I can say now is that I'm a communist sympathizer :)
english translation of the interview (Score:2)
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.)
The word you are looking for is distribution. (Score:2)
Re:Why is LISP superior? (Score:2)
A few months ago, Erik Naggum posted some code that implemented a simple infix syntax for Common Lisp. There is already a fairly feature-complete infix package floating about the AI Repository at CMU, but Erik did this as an exercise, and he made this change (which can be loaded into ANY ANSI-conformant Common lisp implementation) in about 20 lines of code. (Search for the text "trivial-infix-reader" and the author "erik@naggum.no" on DejaNews.)
I think the relative ease with which one can make radical changes to the *language itself*, all on the fly no less, and without resorting to language or code outside the standard, sets Lisp apart from e.g. C or Java or Python. There is *no* way to do something equivalent (e.g. switch to a prefix notation) in C without some serious hacking on the C compiler's parser (which is completely outside the realm of the ANSI C specification). Never mind the fact that C's macro system is only a glorified search-and-replace, whereas Lisp's macro system (including reader macros) allows the user to truly transform the language.
Rev. Dr. Xenophon Fenderson, the Carbon(d)ated, KSC, DEATH, SubGenius, mhm21x16
Re:Interesting . .from the interview: (Score:2)
-----------
"You can't shake the Devil's hand and say you're only kidding."
Re:Why is LISP superior? (Score:5)
Your question is based upon false presumptions -- that such problems exist. Since one can write a lisp interpreter in a number of languages: C, C++, Perl, Pascal, numerous variants of assembly, etc.; it must be true that any problem solvable in Lisp can be solvable in these other languages (if it seems that you have an instance where this is not true then write your LISP solution, and feed it into a LISP interpreter written in the other language).
This, however, does little to address issues of usability and suitedness of languages to problems. Just as C++ is an arguable improvement over C (and that is an ongoing argument at that), but C can do everything that C++ can do (think about what it takes to write a C++ compiler in C; while not trivial, with name-mangling things get easy quickly). Still there are many who can develop large systems more quickly in C++ than they could while writing in C, due primarily to the types of abstractions made available.
I read RMS as saying that the fact that programs in LISP are represented not as character strings but native list data structures which preserve program structure as data while remaining executable is one reason to conclude that LISP is a "more powerful" language than the others. It is more powerful in that it enables skilled LISP programmers to do things "better" than skilled programmers of other languages. I take this to mean that LISP is a "more beautiful" language -- i.e., that makes sense, is complete, and self-reflective.
Take that for what you will. I do the majority of my programming in C/C++/Perl with odds-and-ends languages for special tasks. But, I spent a few years doing a lot of LISP and it is a beautiful language. Ever see a LISP interpreter written in LISP? Takes about a page of type for a full-featured interpreter. In my Principles of Programming Languages class in graduate school one of the problems on our final examination was "given the LISP interpreter written in LISP on the previous page, modify the interpreter to support call by reference argument passing semantics." The solution was a couple of lines of code. There's a certain Zen to LISP programming that you don't find anywhere else.
Unfortunately, there isn't much call for LISP programs out there in the business world or the OSS world, and the art languishes. [ IMHO one of the reasons is that the average programmer can't find the Zen between the parentheses -- not a problem with a language, but a problem with the average programmer ]. LISP is arguably a "more powerful" language than the others in wide use, but unfortunately the programmers in wide use are not as powerful as RMS.
YMMV. My $.02. Do not taunt happy fun LISP. Please keep hands inside vehicle. Not for olfactory use. Keep away from eyes. etc.
Write a type assitant! (Score:2)