Slashdot Mirror

Now if I could only find a book as good to introduce me to Common Lisp.

Now if I could only find a book as good to introduce me to Common Lisp.

(With many apologies to Paul Graham)

What Kazaa Lite has now is equivalent to blacklists of spammers and spammers domains. We have already determined this strategy alone won't solve the problem.

The next logical step is to combine the lists with a distributed statistical filter capable of identifying RIAA hosts by search pattern and IP pattern. Since it is happening in a connected network, each peer filter can then broadcast its guesses and receive other peers guesses. Locally you can build a trust list based upon the likehood of search comming from a RIAA host.

Obviously this have problems.

One problem is the lack of significant search samples to make decisions. We would have to see an implementation to discover if it is mathematically feasible.

RIAA can also start trying to close down sharers by broadcasting their IP as "riaa-like" from a great number of peers. The way to avoid this is having all peers checking "the evidence". If the sharing IP and its searches do not match RIAA pattern, the call is probably bogus and those IPs broadcasting it are probably RIAA's. Backfire on them...

Another danger is RIAA using a range of IPs large enough to endanger the network connectivity. This is probably too expensive, but RIAA is probably too rich too.

Anyway, my point is that since the data is there (RIAA is searching the networks for the sharers), one can always analyse this data and try to extract as much information as possible from it.

So basically, you're rehashing the rest of my message while appearing to argue with me. I'm unclear as to what exactly I said that you disagree with, quite frankly.

As far as I could tell, stonecypher appeared to be using overwhelming, excessive, way-over-the-top sarcasm to make a point. And you still missed it :-).

The point of stonecypher's statement(s) is that while you could write "a massively OO object exchange system in assembly"... or indeed implement any other kind of software development project in an utterly inappropriate programming language... it would be ludicrous to do so.

Implying that all programming languages are equally powerful because they're all Turing equivalent is - well, it's nonsense. Paul Graham explains it much better than I can in his article Beating the Averages. Focus on the section labelled "The Blub Paradox", although the rest of the article is also good.

Essentially, just because two programming languages are Turing equivalent, that doesn't mean anything about how powerful they are. Similarly, just because two human-controllable vehicles both have wheels and travel along the ground doesn't mean you can equate a skateboard to a car.

A good line I've heard a few times about these sort of language non-comparisons is something like "yeah, you can do this in C, but only by writing a Lisp interpreter in C and then writing the rest in Lisp!" Codified (slightly) more formally as Greenspun's Tenth Law/Rule of Programming: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp."

As for online resources, a good place to start is probably the cliki, a CL-related WikiWeb with emphasis on free software.

There are some free online books, like Successful Lisp, Loving Lisp - the Savy Programmers Secret Weapon, or Paul Grahams On Lisp (which isn't really a beginners book, but very enlightening once you are familiar with the basics). The Common Lisp Cookbook is not as big as it should be, but does contain useful information, and is growing.

An absolutely invaluable reference is the HyperSpec, a heavily hyperlinked online version of the standard. You definitely need that.

You might also want to check out the comp.lang.lisp newsgroup, or the #lisp channel at freenode. Depending on your specific interests, the LispWeb or Clump mailing lists may be interesting, the first deals with web programming using Lisp (surprise!), the second with general application developers issues.

Last but not least, there has been a movement of Lispniks gathering to drink beer and talk about all things Lisp (and everything else) in the last months. Check out this site, maybe there's a user group in your area. The people I've met so far are generally a nice and interesting bunch, and won't bite you even if you don't know the argument lisp of update-instance-for-redefined-class from the top of your head.

Happy hacking!

He's probably talking about the book ANSI Common Lisp written by Paul Graham :)

've heard that somewhere before...

Oh yeah. In my ANSI Common Lisp book. Something about the real power of Lisp being that everything, including the program itself is just a tree structure.

Or on Paul Graham's website. Wonder if Gosling will be coming up with something to compete with Graham's ARC...

they should filter their email better and stop having their children sign up for the sex mailing list in the first place.

This is not how spam works. You're operating from the assumption that only people who ask for spam get it. The best spam filter in the world, based on solid research, still needs to be retrained fairly often because of the spammers ability to circumvent spam filters.

Spam is not free speech - its harassment hiding behind free speech and its costing everyone plenty of real dollars. Legistlation is required because its apparent only the threat of jail time will incite these miscreants to play nice. Civil suites are nice, but it alows the spammer to continue for years while the case is resolved.

take care of spam yourself with a good filter, deal with it the same as you do your mail box with postal mail

This article raises an interesting point. When a spammer successfuly hijacks address space and uses it to send spam, his IPs are naturally going to appear on various blacklists before too long.

The problem isn't limited to blacklists, either. Bayesian spam filters will quickly learn to recognize Received-From headers bearing the stolen IPs. Collaborative hashing filters will also be affected, to a degree.

So...the spammer steals a subnet, uses it to spam for awhile, and then is either shut down or abandons his activities. He leaves behind a zone of "scorched earth" -- addresses that are effectively cannot host a mail transfer agent. It is now the job of the next legitimate recipient to clean up the spammer's mess. He might not even notice anything's wrong until half his emails have gone missing and the other have are bounced with mysterious messages. Having identified the problem, it is now up to him to track down various blacklists and get his addresses removed. The damage done to the Bayesian and collaborative filters simply cannot be undone. Mail will be lost.

To me, this is the real tragedy. Once an address block has been used for spamming, it's effectively ruined until someone inherits it and puts a great deal of time and effort into restoring its good reputation.

With none of the performance.

Anyone still convinced that Java is neato needs another viewpoint; Paul Graham's is reasonable.

Anyone convinced that Sun is anything different than Microsoft, oh, except for being less successful, is delusional. How's that Java standard comin'?

Avoid this crap. Go C++, or better yet Eiffel with C, and stop kidding yourself that Java getting a shiny "for" syntax is a reason for celebration.

"What's that? Oh yes sir! I'll have those UML diagrams detailing the Bloggorgian-Rienmarch Reverse Upside-Down Cake Factory Singleton Dweeboid Pattern for you by next month! Then we can start coding!"

A Plan For SPAM.

The BBC article mentions Paul Graham, and I found his page (and some more information on Bayesian networks for spam filtering) here:

Paul Graham's spam page

He talks a little bit more about the technical aspects there.

Check em off:

Homebrewing
Gardening (vegetable/food)
Pottery/Ceramics
Painting (art and walls)
Reloading (cartridge ammunition)
Woodworking (as storage space allows)
Cooking (most days)
Metalsmithing (lathe, welding, etc)
Breadmaking (several times a month)
Photography and developing/printing (too expensive at the moment)
Cloth dyeing (well, more my mom and sister than me)

I usually pick these up when the timing is convenient, learn enough to be competent, then move on to the next thing, but eventually come back around in a circle later to learn more about the subject when it's relevant again.

Ultimately my goal is to have a smallish farm in a semi-rural area near a university town, build my own house, and include lots of greenhouse, storage, and workshop space.

Oh yes, and cogenerate my electricity and heating with net metering or mutex switched grid/local electric. Not to mention passive solar heating, cool reflective roofing, and a combination of thermal mass and evaporative cooling.

if you start acting like an economist and figuring out "economic profits" it turns out that there are none. But that's true in any market economy, you can't make anything more than anyone else does doing similar things.

We do it because we like it. We like it because that's the kind of people we are. We're drawn to quality and efficiency. See Paul Graham's article on hackers and painters. To quote:

"What hackers and painters have in common is that they're both makers. Along with composers, architects, and writers, what hackers and painters are trying to do is make good things."

Thunderbird has a built-in autolearning spam filter. You just recieve your e-mail and when you see spam, mark it as such (by clicking the little 'Trash' Icon). And it is sent to the Junk folder and any future e-mail with similar structure will be blocked. As you mark e-mail as junk (or not junk) it learns and adapts. I have an almost 0% false-positive rate, and at least 95% catching rate. It uses the Bayesian algorythm.

That this will only create a sense of accomplishment. Eventually spammers will provide throw away addresses that simply reply to get on the white list anyways. The reason they don't do it now is because this challange-authenticate is not widely accepted.

I still think, and am quite happy with, a Bayesian Filtering application that Mozilla Mail currently offers. Very little spam leaks through and I have only had one false positive in almost 3 months of using it.

By the way, anyone caught sending me spam will be forced to work at home stuffing Viagra into inkjet cartriges. Be afraid!

The problem with using the filter described is that a good portion of spammers DO send from legitimate e-mail addresses...just usually not their own. Sometimes it's even being sent from the person receiving it (by simply faking the from: tag)

Seeing how this failed miserably, I now use two different methods of spam prevention. it's cut spam down to roughly 2 per day (which means each user might see 1 spam/month avg.) with 0 false positives over the first 30 days of testing.

Put simply, if every mail server in the world were to switch to using decent filters, it would make spam all but irrelevant and thus we wouldn't all be sitting here reading about it.

The concept of putting a macro facility into Perl is revolting. It would be much more pathetic that the C preprocessor. (Anyone who thinks the C preprocessor is an acceptable macro facility should stop programmimg immediately before they do any more damage, and go back to CS101 and read Paul Graham's On Lisp.)

Macros are the one most important thing from Lisp that Python is missing. But Python can certainly manipulate code at runtime. The fact that Python code is not literally structured data is alleviated by the fact that the parser and compiler are available as part of the Python runtime, and you can easily manipulate and evaluate strings in Python. Certainly that's nowhere near as useful as Lisp macros, but at least you're not up a creek without a paddle as you would be with Java or C++. Yes I know you can link the Java compiler into Java, or call the C++ compiler as a sub-process from C++, but that's a totally impractical kludge, not a language-level macro facility.

I'm glad that lambdas have been fixed in Python since they had problems in the earlier days, but I don't know what you mean by "severly limited form". If you ask me, it's Java's inner classes that are severly limited and extremely clumsy (and they also weaken the security system).

Continuations are not as useful in every-day programming as most CS grad students with no experience in the real world would have you believe. Just what problem are you actually trying to solve, that you can't solve with threads, exceptions, generators, or better programming techniques?

As a matter of fact, the Python architecture was easily modified to support continuations (called "Stackless Python"). The main purpose for implementing continuations in the interpreter was to get the interpreter's state disentangled from the C stack, which makes it much easier to embed the Python interpreter in other applications that can't relinquish control of the program counter. For example, with stackless python you can call into the Python interpreter every time slice from a timer callback, and Python can block on network input or whatever, and still return to the caller, so the application doesn't have block inside of Python during its timer callback. That makes Python easier to integrate (and therefore more practical), because it removes constraints on how you can call into the interpreter (because the call can return if the interpreter needs to block). It also enables Python to support tail recursion. But hardly anyone uses continuations in their full glory and splendor, for normal everyday programming.

Also, Python now has "generators" (aka "weightless threads" or "coroutines"), which are quite useful for some of the other common uses to which people put continuations, but they are much easier to use and understand.

CLOS is great, but I don't miss it most of the time, because I'm happy with the current object system in Python. Python's object system is quite simple, practical and flexible, and can be easily extended in its own way. ScriptX's object system was a lot like CLOS, as was Dylan's. But again, you usually don't need the enormously powerful generality of CLOS, and it comes at a cost in speed, space and complexity, that most people aren't willing to pay.

I previously worked on ScriptX at Kaleida, and have written lots of ScriptX code. In some ways i

There are better methods. Message analysis (ala SpamAssassin), spam clearing houses (ala Razor), RBLs, bayesian filters, and sender address verification. I use all five at my site, and my users are happy.

Plus, can you imagine a potential client of your company e-mailing for information, only be sent a TDMA message? I'd bet money that person would either not no what to do, or just ignore the message and think you never got back to them.

Paul Graham put together a brief list along those lines, titled What Languages Fix.

This may get a little too philosophical, but I'm going to give it a try. What is the key difference between programming and parenting?

There is a very fundamental difference. When was the last time your program told you "NO!" for some reason other than human error? I know it may seem like your computer has a mind of it's own, but in reality, it can only do what it is EXPLICITLY told to do. Actual intelligence is capable of not only making rational decisions based on pre-defined rules, but also extrapolating those rules to unrelated circumstances as well as making decisions completely AGAINST reason.

I was very heavily into robotics and AI in college, and the fundamental difference between AI and real intelligence is NOT the ability to learn, but the ability to make abstract choices based on a prior, yet not exact (or often even similar) rule set.

For example: Paul Graham's "A Plan For Spam" contains software that, after some initial conditioning, will recognize new spam based on old rules and adapt those rules to continue to do it's job. Is it true AI? No. It cannot function outside it's exact rule set. Send it a spam message in russian, and I bet it has no idea what to do, even if there are porn pictures in it. Even more apt would be whether it could identify spam websites without additional human coding.

Currently, the method for AI research, especially among those not in the field, is "how many rules can we pass it until it seems real." This, IMHO, is a poor schema without much hope for success. Evolutionary programming seems to have a much more realistic and probable chance towards succeeding. For some good reading on the subject, check out Blondie24: Playing at the Edge of AI

-Ab

My first programs were in FORTRAN, for the moment I'm doing Java, and I'm hoping for Lisp in another 10 years...

Not a bad goal. Lisp has certainly weathered well over the years. It has fallen somewhat out of favor in the past decade. I attribute that to two things. First, it has suffered by association with AI. Second, Lisp is not a language one grasps quickly. The power is contained in idioms and composition of features one with another. That doesn't invite the newbie.

When you can look at Paul Graham's book On Lisp and Andrei Alexandrescu's Modern C++ Design and understand the similarities, you are ready to code in any language.

Because lisp, like all tools for highly skilled workers, takes time to master. People who have taken this time are fewer, and so, more expensive to hire.

Most companies will foolishly opt for 3 code monkeys (i.e., inexperienced, unproductive programmers) rather than one lisp master at 3 times the salary. This overlooks the fact that the lisp master is often 5 or 10 times more productive.

It's the same reason businesses choose cheap everything. Bean counters rarely look past initial cost.

Paul Graham's success with viaweb (now Yahoo Store), and ITA Software's success with Orbitz suggests that the increased productivity of a handful of lisp hackers can easily beat whole cube farms of code monkeys when time to market counts, which is, essentially, always.

To summarize, what you're missing in this picture is that management decisions such as implementation language are often made by managers, not master programmers who actually know about such things.

Because lisp, like all tools for highly skilled workers, takes time to master. People who have taken this time are fewer, and so, more expensive to hire.

Most companies will foolishly opt for 3 code monkeys (i.e., inexperienced, unproductive programmers) rather than one lisp master at 3 times the salary. This overlooks the fact that the lisp master is often 5 or 10 times more productive.

It's the same reason businesses choose cheap everything. Bean counters rarely look past initial cost.

Paul Graham's success with viaweb (now Yahoo Store), and ITA Software's success with Orbitz suggests that the increased productivity of a handful of lisp hackers can easily beat whole cube farms of code monkeys when time to market counts, which is, essentially, always.

To summarize, what you're missing in this picture is that management decisions such as implementation language are often made by managers, not master programmers who actually know about such things.

A quick look at Paul Graham's site will show that he clearly believes the answer is lisp.

A lot of Lisp people are gravitating towards Python-- mostly because it's a good programming language that offers a lot of what Lisp offers without the stigma attached to Lisp. Over the last ten years, programming languages have started to approach Lisp; Graham writes about it in Revenge of the Nerds. From this:

You could translate simple Lisp programs into Python line for line. It's 2002, and programming languages have almost caught up with 1958.

I, and the Perl-oriented students in my Lisp class, are convinced that Perl 6 is shaped the way it is because Larry Wall looked at Lisp and thought, "Hey, that's good!"

Paul Graham is a well-known Lisp programmer. He didn't beat us over the head with it in his article, but I'm pretty sure that he considers Lisp (Common Lisp, in particular) to be that good language, for yesterday and today at least.

I suppose that it's an acquired taste, but I'm convinced that it's a taste well worth acquiring. Here is a little screed I wrote to explain why I hold that conviction. Graham wrote several articles which tell his reasons. Some which pop to mind are: Beating the averages, Lisp in web based applications and What made Lisp different

By the way, Lisp doesn't have to be very slow. Here is a pointer to a paper which might get you started.

Paul Graham is a well-known Lisp programmer. He didn't beat us over the head with it in his article, but I'm pretty sure that he considers Lisp (Common Lisp, in particular) to be that good language, for yesterday and today at least.

I suppose that it's an acquired taste, but I'm convinced that it's a taste well worth acquiring. Here is a little screed I wrote to explain why I hold that conviction. Graham wrote several articles which tell his reasons. Some which pop to mind are: Beating the averages, Lisp in web based applications and What made Lisp different

By the way, Lisp doesn't have to be very slow. Here is a pointer to a paper which might get you started.

I get the impression this guy has never been near a serious product.

I don't know why more people/ISPs aren't using this. This system seems to be the most effective because it doesn't have silly little measures (that block the word "cock", for example, but not the word "c0ck") -- it seems to rate the spam based on its content, which no spammer can get around.

Please check it out.

Also, does anyone else forsee spammers hiring people to sit around and answer verification questions all day? It's a hell of a lot faster to do than actually placing calls to people and talking to them, and people (well, if you want to call telemarketers "people", I think they're sub-human) do this all the time.

The Register is a rag. Can we please stop quoting from it for anything important?

For simple, Bayes-only systems Paul Ghram has seen false positive rates around 0.03%, and SpamAssassin sees only slightly more than that on it's large database of mail, much of which is often in the database because it's pathologically spam-like.

Systems like Razor2, Bayes and blacklists make the system even more accurate, though often not in ways that are easy for a benchmark to detect (you need to leave SA running long enough for bayes to get trained by the rest of SA; Razor2 is time-sensitive and blacklists change in quality over time).

Both things - detecting dupes and creating dupes - should be a simple thing today. Concerning the first one, you could easely use a spam filter, modify it, and run it over all new posts. Whenever something bears high similiarity to a former /. article, the system should print out a dupe-warning. Of course, sometimes there is wanted similiarity between different posts (like Mozilla 1.0 is out, Mozilla 1.1 is out, Mozilla 1.2 is out, Mozilla, 1.3 is out... and, guess what? Mozilla 1.4 alpha is out!)

"First, Scheme requires GC. Kernel memory isn't GC'd."

- Python advertises its support for first-class functions, but I can't seem to get closures to work.

Actually, the revolution already happened, and nobody noticed.

There's a good and quick article, written by Paul Graham on why his new 100 year language isn't obect-oriented. I think those LISP designers were on to something...

There's a good and quick article, written by Paul Graham on why his new 100 year language isn't obect-oriented. I think those LISP designers were on to something...

The possible uses for more computing power was explored recently in an article here. The article I am referring to is Paul Graham's "The Hundred Year Language" and should chill the "my 4.77MHZ XT with a 8087 FPU is all I'll ever need!" crowd a couple of degrees.

Parent post: "He admits that the entire essay is based not on fact, but on his spooky 'Hacker's radar.'"

Not so. In fact, this is a gross mischaracterization of his essay. He enumerates 12 very specific reasons, such as:

from Java's Cover

"9. It's designed for large organizations. Large organizations have different aims from hackers. They want languages that are (believed to be) suitable for use by large teams of mediocre programmers-- languages with features that, like the speed limiters in U-Haul trucks, prevent fools from doing too much damage. Hackers don't like a language that talks down to them. Hackers just want power. Historically, languages designed for large organizations (PL/I, Ada) have lost, while hacker languages (C, Perl) have won. The reason: today's teenage hacker is tomorrow's CTO."

Moreover, he argues, and quite convincingly, that one cannot afford to make the investment of time and energy to determine if every new fad language is actually worth retooling your whole consultancy or enterprise around. One *must* read the signs surrounding a language before one bothers to get up to speed on it, which might take a year or more of full time effort.

Paul Graham is saying that the evidence surrounding Java is very damning, because it shows all the signs of a language beloved of large, bureaucratic organizations (e.g., the Department of Defense), and none of the signs of languages beloved of truly excellent programmers (e.g., C, Perl, Lisp). Java is all about managerial control of programmers who have very restricted power. Real programmer's languages are all about giving the programmer great power, and trusting that he knows what to do with it.

It's no surprise that he feels future languages 'will be list-based' and 'arrays will be obsolete'.

He wrote another article in 2001 which declared Java a 'bad technology,' and not because he knew Java or had ever used it, but because his 'Hacker's radar' detected it.

Believe it or not, but there is a reason why Lisp users are more often also Lisp lovers than Java users are Java lovers: Lisp has very few primitives, and very many high-level tools built upon it. While you have a productive toolset from the beginning, you are always able ot change everything if it doesn't happen to fit your problem exactly, using the more basic tools.

For example, Lisp object systems are implemented in Lisp itself. Take that together with Lisps ability to redefine programs at runtime, you get something way more powerful that Java's object system. If you don't like an object system, change it until you do, or write your own. Everything in the language not only makes this approach of programming by language-tweaking possible, but encourages it - don't like the default way multiple inheritance is done in CLOS, the standard Lisp object system? Use the meta-object protocol to implement a metaclass that implements your weirdo inheritance rules.

Conventional languages like Java don't allow you to do this, instead they force you to think the way it's invetors wanted you to (which is not neccessarily the way they like to think themselves, as in the case of COBOL or Java). Lisp is not a single language - it is a toolkit to easily build a language that is perfect for your task.

Why is paulgraham.com's bookmark icon the Yahoo! logo?

It's no surprise that he feels future languages 'will be list-based' and 'arrays will be obsolete'. He wrote another article in 2001 which declared Java a 'bad technology,' and not because he knew Java or had ever used it, but because his 'Hacker's radar' detected it. Yes, he actually wrote an entire essay about this.

It frustrates me when these nuts get the attention they do. This guy publishes a couple of computer books and thinks he's Donald Knuth or Martin Fowler...

2. Disruption: Spam brutally disrupt your every-day routine. I can waste an hour a day going through your personal or work mailbox to delete spam. Email is such a personal, direct form of communication, having so many unsolicited messages in your mailbox is intrusive and disruptive.

Paul Graham (the guy who wrote POPFile, probably the first bayesian spam filter) has a great eassy about why spam is bad. I couldn't say it better myself.

For some more elaboration on the "day care for teens" position, here's an article that you may find interesting. (You may have seen it already; it was on slashdot a while back).

Now wait a second. I'm all for the enlightened individual, and I think I put in my dues in the public school system. Homework is well and fine for certain things, but aren't we asking a bit much of our children?

Consider this. By your own numbers a college student will put in about 45 hours a week in total school work. That same student will have the remainder of the week to him/her self.

The highschool student, one year YOUNGER than the college student has 5 eight hour school days plus, lets say 30 mins of homework per class, or 3.5 hours a night. That comes out to 11.5 x 5 = 57.5 hours a week.

More importantly, the majority of that is in giant eight hour blocks, usualy in schools with poor lighting, horrid ventilation, and a stifiling intelectual environment spent teaching to the lowest common demoninator.

Is it any wonder that your average college student is THRILLED to be where he is and your average HS student considers his life to be an endless tedium of pointless drudgery punctuated by periods of abject misery?

The maturity levels here are close, one year. The academics is where it differs. There was a /. artical on this not to long ago. Re-read it. Remember why High School is so mindnumbing?. Honestly, this kid reads slashdot... which means he's probably not a total moron. I remember my highschool homework. It wasn't that it was difficult, it was time consuming and rather pointless. Maybe if his teachers assigned less homework that challenged him and made him think more, this wouldn't be a problem.

Note - I learned many things in school. Spelling was not one of them.

What an excellent way to help young people become successfully integrated into society (formerly discussed here). Of course, if the Bush administration has its way, then this really will help...the kids will be more accustomed to destructively invasive surveillance than their parents; they'll be all ready for this brave new world....

It's really an exciting time for users of computer languages.

A very good (free) book on this topic, although not dealing too much with custom syntax, is On Lisp by Paul Graham, the Bayesian spam-filter guy.

And that's exactly the way it ought to be. I feel so sad for these guys here who feel like they're being taken advantage of.

I liked Paul Graham's observation about italian teenagers in his article on nerd unpopularity. The italians don't have as many seriously disturbed nerdy teens, in large part because their families support each other and become the most important part of their lives.

Of course there's always Philip Greenspun's guide to Java Monkeys to support those of us who are being taken advantage of.

I helped my Fiancee buy a used laptop for her mom. Yes, I've spent several hours on "tech support" over the phone from 3000 miles away. I just feel that it's more than enough to repay them for the way they treat me when I fly out for holidays, and the interesting things I learn from them.

I also think it's worth it because they obviously get a lot out of internet access. Her mom is a library fiend, constantly checking out books on myriad topics, now she also has access to a world of information that doesn't require reserving books, or driving out in 3 feet of snow.

If you're really getting steamed about tech support, perhaps it's time to take more control over how it works?

there's nothing that beats Knoppix for ease of use, easy recovery, and local and remote administration.

Not bad for about 5k lines of commented code. The largest source file is the ML grammer for the C language.

For their pure expressive power I don't see why FP languages get more respect. But I guess folks like Graham would mind that.