dwal...@syncreticsoft.com (Damond Walker) writes: > I'm always interested in how people "came to something." In this > case it's Lisp. How about relaying how you "came to Lisp?"
I first heard of Lisp while I was in high school in the mid-1980s - probably from reading Steven Levy's _Hackers_, but possibly from another book I read around the same time. At the time, my computer was an Apple IIc and Assembler/Basic were mostly what I worked with, though I never mastered assembler. At this time, I also worked with Pascal [mostly used Borland Turbo Pascal on PCs] and Logo for the Apple II [loved those turtle graphics...], while getting exposure to Prolog, Fortran and HyperCard Scripting...
Between 1988 and 1990, I learned C and Scheme, as well as participating in an experiment conducted by the CMU Psychology Department related to teaching Lisp [probably Common Lisp, although I'm not sure since it was a very small subset]. Scheme came easiest to me, as it "just made sense." I was also impressed at how easily we could switch to a "object oriented" [via message passing] style in Scheme...
Between 1990 and 1997, I worked in C and various scripting languages including Perl and Awk.
Between 1997 and 2002, I added some C++, Java, ML, as well as revisiting Scheme. Since I prefer more abstraction in my programs, I find writing C code to be tedious - these OO-oriented and functional-oriented languages were more enjoyable to me than plain, old, vanilla C.
During all this time, I was an avid Emacs user, so I hacked [in the sense of chopping roughly with no real skill] at ELisp.
Finally, in 2002, I bit the bullet and decided to learn Common Lisp. I *love* Common Lisp and am enthusiastically "building up" the language to support coding the solution to my current problem in "the native language" of the problem domain.
-jon -- ------------------ Jon Allen Boone ipmon...@delamancha.org
Jacek Generowicz <jacek.generow...@cern.ch> writes: > Kent M Pitman <pit...@world.std.com> writes:
> > It perhaps becomes more complicated because the Scheme community > > has a completely different rule and we've added some compatibility > > syntax for mindshare with them, but the rule actually makes our > > rules more complicated.
> > To think about it right in lisp, think of (lambda (x) x) as a > > "name" of a function. So (f 1) has the function name F in the car > > of the form, and ((lambda (x) x) 1) has the function name > > (lambda (x) x) in the car of the form; that is, lambda is an > > "anonymous" name, just like in English when you can say "that man > > over there" in place of "Fred" if you either don't know Fred's > > name or don't choose to name him, but prefer to work by describing > > the effect you want. Likewise, you can say #'f or > > #'(lambda (x) x) and it's pretty consistent. But we added the > > ability to say (lambda (x) x) for compatibility with Scheme
> By this, do you mean having (lambda (x) x) evaluate to a function > [thereby breaking the consistency with f, where simply evaluating f > does not (necessarily) give you a function, but whatever is bound to > f in the value namespace] ?
It's not a question of what it evaluates to. #'f can only evaluate to a function because the function namespace is thus restricted, but f can also evaluate to a function.
I mean (lambda (x) x) evaluating _as_ a function, that is, going through a process some call feval (pronounced "eff eval") is what's at issue, that is, what the processing of a name or lambda expression in the functional namespace--if it's a name, grabbing its function binding, and if it's a lambda creating its closure, ... at least conceptually ... In the case of lambda combinations like ((lambda (x) x) 'a) this is probably done specially by most implementations, without obtaining a function object, but that's an implementation/efficiency issue, not really a definitional issue.
In CL, lambda expressions were originally things that were fevaled, not evaled. It is arguably confusing and overcomplex that they are now both. (I daresay CL programmers are able to handle this complexity. I'm merely observing that it's there.) But it's only an issue while macro forms are present, and lots of things in macro land can be potentially syntactically confusing. Once macro expansion is done, things are simple again and there is only #'(lambda (x) x) as a form; no more apparent references to unguarded lambdas going into the eval half of things.
> My concern was with how many different kinds of things can be bound to a > name without interference, where the grammatical context would suffice > to disambiguate the correct binding. Perl, for instance, has typeglobs, > which is what all names (except "lexicals") immediately refer to; the > typeglob in turn is a tuple of pointers to different types of values > ("scalar", array, hash table, function, etc); and the correct value > referent is determined by syntax. So an expression like
> $foo -> foo ( @foo{ @foo } )
> has determinate meaning in that an object, a method, a hash table and an > array can all concurrently be named 'foo' at the point of > evaluation.
Now I understand. You show very grave signs of Perlite. :)
In theory (and practice), in CL, you can write womething like
Note that FUNCALL and GETSHASH are already part of the language. FIND-METHOD is as well. To support FIND-HASH-TABLE-NAMED and FIND-STRING-NAMED you need to add a few things. You can do do that in Scheme as well (of course, you are missing GETHASH, but that is just one of the problems with Scheme).
So, in general, in CL you can set up as many "namespaces" as you want, and then use the language and the macro systems (i.e. macro characters included) to access the underlying namespace.
E.g. you could have the macro characher @ (Perlite is getting to me) set up some checks, like
@foo ==> (let ((v foo)) (check-type v 'hash-table) v)
But then, why would you like to do that, just to separate things that are already checked for?
> My thanks to Erik, Marco and you. You've been very helpful. Back to > the books and the Hyperspec for me:-)
You are welcome.
Cheers
-- Marco Antoniotti ======================================================== NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488 719 Broadway 12th Floor fax +1 - 212 - 995 4122 New York, NY 10003, USA http://bioinformatics.cat.nyu.edu "Hello New York! We'll do what we can!" Bill Murray in `Ghostbusters'.
* Bruce Lewis <brls...@yahoo.com> | There's a useful conclusion to draw from this. If you throw up your | hands and say it's hopeless for someone who learns Scheme first to then | learn CL, you're closing a door through which many people enter the CL | community.
Sure, they "discover" Common Lisp, but keep writing Scheme in it. Some "think Scheme" even though they are actually learning and using Common Lisp. It is important to inform those who discover Common Lisp that it is not just "a better Scheme". Those who are not challenged in their belief that they can just keep writing Scheme may spread their "take" on Common Lisp faster than those who have figured it out, especially to other Scheme freaks. Scheme is a like a mind-altering drug or some cult that warps people's ability to think straight, and the resistance to it is well-deserved, but precisely for that reason, people need to discover that knowing Scheme is not beneficial to learning a real Lisp.
For instance, the following quote from O'Reilly's Write for Us page¹ relates to deservedly bad experience with Scheme, not to Common Lisp, which is largely if not completely unknown.
However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based training.
It is good that Scheme victims discover Common Lisp, just as with users of any other programming language, but most of the others discover that Common Lisp is a _different_ language from what they are used to, adjust accordingly, and proceed to _learn_ it. Scheme victims seem to lack the appriciation that Common Lisp is an entirely a new language, and just think they know it, without ever getting the point. Just like Java and C have very little in common besides the superficial syntactic similarity, Scheme and Common Lisp have very little in common besides the superficial syntactic similarity. This is just like the racial slur "you people all look the same to me", where a group of people look "similarly different". In some people's minds, there is no need distinguish between them as long as you are not among them. Common Lisp suffers greatly from being similarly different from "normal" languages as the villainous Scheme.
Erik Naggum <e...@naggum.net> writes: > * Bruce Lewis <brls...@yahoo.com> > | There's a useful conclusion to draw from this. If you throw up your > | hands and say it's hopeless for someone who learns Scheme first to then > | learn CL, you're closing a door through which many people enter the CL > | community.
> Sure, they "discover" Common Lisp, but keep writing Scheme in it.
This seems to me a simple matter of proper education. I doubt it's a fundamental property of the universe.
> Scheme is a like a mind-altering drug or some cult > that warps people's ability to think straight, and the resistance to it > is well-deserved,
My bet is that the same is said for Lisp. Education is itself a mind-altering drug and it warps people's ability to think in the way they would have thought absent it. If it warrants resistance, it is not for the per se reason that it alters minds.
> but precisely for that reason, people need to discover > that knowing Scheme is not beneficial to learning a real Lisp.
Well, Scheme intuitions are likely to mislead you in Lisp. But right-handed driving intuitions may mislead one in driving in the UK. I'm not sure that's the same as saying "learning to drive in the UK is without value". I think the important thing is to make sure that people visiting from the UK know that they are not still in the UK. (Heck, I have to make sure people visiting from California know they are not still in California when they try to navigate Boston traffic...)
> For instance, the following quote from O'Reilly's Write for Us page¹ > relates to deservedly bad experience with Scheme, not to Common Lisp, > which is largely if not completely unknown.
> However, we're NOT looking for: Any books on LISP, LaTeX, or > Web-based training.
Could this just mean one is in the pipe? Does anyone know why this would be there? If it is a bad experience, can we find out what?
There presumably have been successful books in this subject area. Perhaps they are worried that all that needs to be known about this area is already available in print. Perhaps we could see if the "ostrich with its head in the sand" or the "hear no evil, see no evil, speak no evil" monkeys are still available for a cover...
> It is good that Scheme victims discover Common Lisp, just as with users > of any other programming language, but most of the others discover that > Common Lisp is a _different_ language from what they are used to, adjust > accordingly, and proceed to _learn_ it. Scheme victims seem to lack the > appriciation that Common Lisp is an entirely a new language, and just > think they know it, without ever getting the point.
(All the more reason there should be a book.)
> Just like Java and C > have very little in common besides the superficial syntactic similarity, > Scheme and Common Lisp have very little in common besides the superficial > syntactic similarity. This is just like the racial slur "you people all > look the same to me",
But as with racial situations like this, there's an inverse problem that occurs when people accuse people of making this slur without checking. Both sides are often guilty of this. People of color green often accuse people of color blue of being 'all alike' and it invites people of color blue to assume all people of color green are out to get them. The solution is to stop going on the basis of the name, and to do the much harder thing of working (from _both_ sides) with people as individuals. I think there is a parallel to your remark here.
> where a group of people look "similarly different". > In some people's minds, there is no need distinguish between them as long > as you are not among them.
Yes, this is so. But it cannot be the case that this set of people is named by the name "Scheme programmers", nor even "people who prefer to program in Scheme", since I can point to counterexamples.
> Common Lisp suffers greatly from being > similarly different from "normal" languages as the villainous Scheme.
I'll see if I can follow up with O'Reilly to find out what the issue is here. If I can get a contact address. I got a 404 when I clicked on the "O'Reilly Contacts" item at the bottom of that page. Maybe they don't want a book on web training because it would challenge the job security of their webmaster. ;)
> > For instance, the following quote from O'Reilly's Write for Us page¹ > > relates to deservedly bad experience with Scheme, not to Common Lisp, > > which is largely if not completely unknown.
> > However, we're NOT looking for: Any books on LISP, LaTeX, or > > Web-based training.
> Could this just mean one is in the pipe? Does anyone know why this would > be there? If it is a bad experience, can we find out what?
> There presumably have been successful books in this subject area. Perhaps > they are worried that all that needs to be known about this area is already > available in print. Perhaps we could see if the "ostrich with its head in > the sand" or the "hear no evil, see no evil, speak no evil" monkeys are > still available for a cover...
I think it might be the fear of a saturated market. I'm guessing that's the case with LaTeX -- both because I personally think that subject is covered quite well in the English language, and because of this book: "LaTeX par la pratique", <http://www.oreilly.fr/catalogue/latex.html>.
-- /|_ .-----------------------. ,' .\ / | No to Imperialist war | ,--' _,' | Wage class war! | / / `-----------------------' ( -. | | ) | (`-. '--.) `. )----'
> I'll see if I can follow up with O'Reilly to find out what the issue > is here. If I can get a contact address. I got a 404 when I > clicked on the "O'Reilly Contacts" item at the bottom of that page. > Maybe they don't want a book on web training because it would > challenge the job security of their webmaster. ;)
Hehe, maybe he himself has added 'web training' to the list of 'not-wanted' subjects... :)
Anyway, the page you were looking for seems to be this one:
In article <sfwk7re88br....@shell01.TheWorld.com>, Kent M Pitman
<pit...@world.std.com> wrote: > Erik Naggum <e...@naggum.net> writes:
> > * Bruce Lewis <brls...@yahoo.com> > > | There's a useful conclusion to draw from this. If you throw up your > > | hands and say it's hopeless for someone who learns Scheme first to then > > | learn CL, you're closing a door through which many people enter the CL > > | community.
> > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> This seems to me a simple matter of proper education. I doubt it's a > fundamental property of the universe.
That's a pretty arrogant thing to say. As someone who writes Scheme code in Common Lisp (apparently) I take umbrage at your claim that 1) this is self-evidently the wrong thing to do and 2) that I do so because I haven't had a "proper education". Tell me, what do you consider a "proper education"? I've read the hyperspec, CLTL1&2, Norvig, both Graham books, Quiennec, and about ten years worth of c.l.l., not to mention every paper of yours that I could lay my hands on. What would you have me do instead?
* Kent M Pitman <pit...@world.std.com> | This seems to me a simple matter of proper education. I doubt it's a | fundamental property of the universe.
It seems to me that Scheme victims are far less aware of the need for re-education that users of any other language. This is a level of language-design arrogance that comes with most Scheme texts and material that rubs off on students who think they have found the One True Design.
| My bet is that the same is said for Lisp.
Well, if "Lisp" here means Common Lisp, I have never seen it.
| Education is itself a mind-altering drug and it warps people's ability to | think in the way they would have thought absent it.
True, but I said thinking straight, not keep thinking crooked.
| If it warrants resistance, it is not for the per se reason that it alters | minds.
No, but any "education" that causes people to become unable to cope with the world the live in, when they could cope just fine previously, has good reason to be met with resistance and the association with brain- washing cults is normally not welcome.
> However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based > training.
| Could this just mean one is in the pipe?
Nope. This is policy.
| Does anyone know why this would be there? If it is a bad experience, can | we find out what?
I have tried, but I have only off-the-record comments and reasoning. If you have more success, that would be great. However, what I have heard is the old "Scheme frightens people", which is true, and then "Scheme is a Lisp", which is not, so "Lisp frightens people" follows, which it _should_ not even if the second premise were true. For a long time, my conclusion has been that Scheme really is harmful to people's ability to think properly and results in a perspective on programming and on problem solving in general that requires the equivalent of psychotherapy to find out what horrible "childhood" you had and how it affects your adult life. In general, I have found Scheme to be an extraordinarily _limiting_ language, not the least in the warped idea that all code must be elegant and all solutions minimalistic, that "dirty tricks" must be avoided at all cost, etc. This fear of getting dirt under their nails is perhaps the most damaging effect of working with an over-elegant language that places so much focus on doing The Right Thing. The fact that the Scheme language is so incredibly _tiny_ is a testament to how _little_ you can do in real life that qualify as The Right Thing. If more One-Right-Thing Maximally-Elegant Final Solutions were possible, they would have gotten into Scheme, right? So _everything_ else just has to be dirtier than Scheme, but this never dawns on some people. Some people react with hostility to the expressed notion that "we're clean, you're not" that comes with languages that have excluded everything that was not "clean" enough. (Any similarity to dissing the unwashed masses is intentional.)
I think Scheme _deserves_ its really bad reputation and should not be taught or used. I would rather teach people Java and rescue them later than even tell them about Scheme. At least they will have gotten some exposure to that dirty old Real World and Common Lisp will be seen as an improvement. Too many Scheme victims regard anything after Scheme to be inferior and uglier and this simply does not help them to learn anything.
/// -- In a fight against something, the fight has value, victory has none. In a fight for something, the fight is a loss, victory merely relief.
> * Kent M Pitman <pit...@world.std.com> > | This seems to me a simple matter of proper education. I doubt it's a > | fundamental property of the universe.
> It seems to me that Scheme victims are far less aware of the need for > re-education that users of any other language. This is a level of > language-design arrogance that comes with most Scheme texts and material > that rubs off on students who think they have found the One True Design.
I somewhate agree with the perception of the "One True Design" arrogance. There is a beauty in the simplicity of Scheme, but that beauty is all there is to it. It's nice thing to gander and gawk and perhaps admire from afar, thats about it. Once the realities of the programming world appear, and Stuff starts getting bolted on to the system, you lose that beauty and elegance. Once at that stage, the question then becomes "Why Scheme?". Why indeed.
> > However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based > > training.
> | Could this just mean one is in the pipe?
> Nope. This is policy.
> | Does anyone know why this would be there? If it is a bad experience, can > | we find out what?
[ no books because Scheme, ergo Lisp, is Scary...*snipped* ]
I would have simply thought that the market for Lisp books in general was simply too mature. Pretty much any CL book in the past 10 years is completely relevant and up to date today.
They only common CL book that CL itself has actually "passed by" is CLTL2.
I think that a good book on CLIM (something beyond an API reference, more like "The CLIM Way"), or a more focused book on Lisp Programming Techniques and Optimization (going beyond PAIP and On Lisp) would be nice. But, I can see those being fairly niche books, and perhaps too vendor dependant.
> I think Scheme _deserves_ its really bad reputation and should not be > taught or used. I would rather teach people Java and rescue them later > than even tell them about Scheme. At least they will have gotten some > exposure to that dirty old Real World and Common Lisp will be seen as an > improvement. Too many Scheme victims regard anything after Scheme to be > inferior and uglier and this simply does not help them to learn
anything.
The only thing that Java really lacks as a good First Language, I think, is an interactive environment to play around in. The only good thing Scheme would do is put the silly fear of S-Expressions and first-class functions out of peoples minds. They were my biggest hurdles getting into this environment.
In article <3cb5f7e9$...@news.nntpserver.com>, Will Hartung wrote:
> "Erik Naggum" <e...@naggum.net> wrote in message > news:3227545352491956@naggum.net... >> * Kent M Pitman <pit...@world.std.com> >> | This seems to me a simple matter of proper education. I doubt it's a >> | fundamental property of the universe.
>> It seems to me that Scheme victims are far less aware of the need for >> re-education that users of any other language. This is a level of >> language-design arrogance that comes with most Scheme texts and material >> that rubs off on students who think they have found the One True Design.
> I somewhate agree with the perception of the "One True Design" arrogance. > There is a beauty in the simplicity of Scheme, but that beauty is all there > is to it. It's nice thing to gander and gawk and perhaps admire from afar, > thats about it. Once the realities of the programming world appear, and > Stuff starts getting bolted on to the system, you lose that beauty and > elegance. Once at that stage, the question then becomes "Why Scheme?". Why > indeed.
I wonder if it still has beauty in your eyes when you come to that conclusion. How can something that turns out to be bad have beauty at all? Maybe it first appears to be beautiful, then your taste ripes, and it isn't beautiful anymore. Is Scheme Kitsch? :-)
Regards, -- Nils Goesche "Don't ask for whom the <CTRL-G> tolls."
g...@jpl.nasa.gov (Erann Gat) writes: > In article <sfwk7re88br....@shell01.TheWorld.com>, Kent M Pitman > <pit...@world.std.com> wrote:
> > Erik Naggum <e...@naggum.net> writes: > > ... > > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> > This seems to me a simple matter of proper education. I doubt it's a > > fundamental property of the universe.
> That's a pretty arrogant thing to say. As someone who writes Scheme code > in Common Lisp (apparently) I take umbrage at your claim that 1) this is > self-evidently the wrong thing to do and 2) that I do so because I haven't > had a "proper education".
I think we're talking about different things.
I was taking the remark more literally. People really do things like:
(defun f (x) (defun g (x) ...) ... use g ...)
This kind of thing works in Scheme but doesn't mean what Scheme people think in CL.
Certainly there are compatible styles one can adopt, but one can also try to pretend CL has Scheme semantics and get in trouble.
Even just relying on tail calling when you've been told it's not reliably there in CL is an example.
> > In article <sfwk7re88br....@shell01.TheWorld.com>, Kent M Pitman > > <pit...@world.std.com> wrote:
> > > Erik Naggum <e...@naggum.net> writes: > > > ... > > > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> > > This seems to me a simple matter of proper education. I doubt it's a > > > fundamental property of the universe.
> > That's a pretty arrogant thing to say. As someone who writes Scheme code > > in Common Lisp (apparently) I take umbrage at your claim that 1) this is > > self-evidently the wrong thing to do and 2) that I do so because I haven't > > had a "proper education".
> I think we're talking about different things.
That's possible. I'm just going on what I've been told here, to wit: that using symbols for everything is the (Common) Lisp way, and using values directly is the Scheme way. I thought that "doing things the Scheme way" and "writing Scheme in [Common Lisp]" meant the same thing.
> In article <3cb5f7e9$...@news.nntpserver.com>, Will Hartung wrote: > > I somewhate agree with the perception of the "One True Design" arrogance. > > There is a beauty in the simplicity of Scheme, but that beauty is all there > > is to it. It's nice thing to gander and gawk and perhaps admire from afar, > > thats about it. Once the realities of the programming world appear, and > > Stuff starts getting bolted on to the system, you lose that beauty and > > elegance. Once at that stage, the question then becomes "Why Scheme?". Why > > indeed.
> I wonder if it still has beauty in your eyes when you come to that > conclusion. How can something that turns out to be bad have beauty > at all? Maybe it first appears to be beautiful, then your taste > ripes, and it isn't beautiful anymore. Is Scheme Kitsch? :-)
As they say, Beauty is in the eye, etc.
If the beauty of Scheme is its simplicity, then that beauty is pervasive and can't be clouded.
If the beauty is that it provides a nice "start from scratch" foundation to build upon, then no matter what you clump on to it, that original foundation is still there.
But if a programmer sees that simplicity and thinks that it will translate into their real world application, that beauty then becomes a lot of work and loses its luster.
If you have to bolt on all of this extra functionality to the base package to get your work done, then the question is do you really still have Scheme, and not something else.
As a completely non sequitor analogy from the world of motorcycles (yes, I agree this is basically off topic for c.l.l, but at least I'm not bitching about Erik...). In some circles of the motorcycling world, one may encounter "a trike conversion", essentially having two wheels in the back rather than one. When someone does this, do they still have a motorcycle? If someone converts a Honda Gold Wing thusly, why not spring for something like a Miata instead?
Certainly the owner wants to keep some bond with motorcyles that a Miata doesn't offer, but he's not riding a motorcycle, IMHO. For me, the beauty of the motorcycle is gone, the dynamics of the riding experience. But for the owner, it apparently is not. Perhaps they value the more open feeling one would get riding a trike, or the comraderie he gets by associating with the other Gold Wing folks who will welcome him with open arms, trike or no.
So, for me, bolting a Common Lisp compatability package onto Scheme gets me neither. Lumping a bunch of "non-standard" and incompatible stuff together removes the "scheme-ness" of Scheme. You end up coding in those frameworks, not necessarily Scheme. People using VC++ for Windows apps are more writing MFC than C++, for example.
Therefor, the luster goes away because with the added cruft, the simplicity get occluded. I was blinded by Schemes simplicity, the novelty of its idioms. But then I found that they're a lot extra work, and soon those idioms became barriers, or were written away and "simplified". Soon after, you're not using Scheme at all, rather some bastard son that no one else is using.
That's interesting. I just got a Tandy 102. I really wanted one of these back when they were new, or one of the little Epson notebooks that competed with them, but they were WAY to high-priced for me back then. Yesterday, I got the Tandy for $5.
I'm comtemplating kludging together a little lisp to fit in it. It has about 24k RAM and an 8085. I've gone looking for info on implementing lisp, and haven't found a lot so far. If you have any of your old stuff, such as z80 code or a version of that old DDJ article, I'd admire to see it.
Just to keep this on topic, I think that my first introduction to lisp was when I tried to use an old symbolic math program called mumath, which was written in a lisp (can't remember which, or what happened to mumath). In order to adjust mumath's parameters, one had to set various variables. I found it painful to deal with those parentheses in edit on a pc. Eventually I found a shareware (or public domain?) lisp in a download directory on the University of Alaska's Honeywell mainframe, and started playing with that, using Wordstar for an editor. I wrote some little programs, but I stuck to Fortran for serious work. I was doing everything on University pc's (Fujitsu and IBM), since they were reluctant to give undergrads an account on the engineering Vax, and Honeywell's Fortran IV was painfully buggy.
I got interested in lisp again a couple years ago when I got started playing with Maxima, which is another symbolic math program written in lisp. This time, I'm taking it a little more seriously, and want to learn to use it effectively. Maybe one of these days I'll get there.
Paul Tarvydas wrote: > My first exposure to Lisp was in a programming languages course circa 1974 > (using Siklosky's "Let's Talk Lisp"). I was baffled by it and intrigued > that I'd encountered a language that I couldn't master.
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of > the first anniversary issue of Byte magazine), with 2K of static RAM and 10K > of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny > Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der > Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet > with commented 6800 assembler code) and sight-read it into the Z80 (the 6800 > version was 4K in size, the Z80 transliteration was 5K).
> Once running well (the final GC glitch (a sight-reading typo) was found > about 6 months later :-), I wrote a simple editor and debugger in lisp and > sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped > out of school for a term and had lots of spare time to kill. The article > was printed on an IBM Selectric typewriter with 11 solenoids, which I'd > salvaged from a Wang word processor.
> I typed in the Lisp compiler from John R. Allen's "Anatomy of Lisp" (lots of > typos in the edition of the book I had) and got it running, emitting Z80 > binary. I had enough of the 12K[*] left over to hold the source code for an > "iota" function (see APL), to compile it and run it.
> pt
> [*] My recollection is a bit hazy. At some point, I coaxed the dynamic RAM > up to 23K [sic - I was using bargain bin TMS 22-pin dynamic RAM chips for > which I had incomplete specs; it turned out that my cpu timing was marginal > for the RAM, but would work if I added entropy to the wire wrapping job]. I > might have built the Lisp compiler only after I had doubled the memory :-).
Erik Naggum <e...@naggum.net> writes: > * Kent M Pitman <pit...@world.std.com> > | This seems to me a simple matter of proper education. I doubt it's a > | fundamental property of the universe.
> It seems to me that Scheme victims are far less aware of the need for > re-education that users of any other language. This is a level of > language-design arrogance that comes with most Scheme texts and material > that rubs off on students who think they have found the One True Design.
It seems that getting over Scheme can be a difficult task. However, it's clear that getting over the getting over of Scheme can take even longer ...
> Just to keep this on topic, I think that my first introduction to lisp > was when I tried to use an old symbolic math program called mumath, > which was written in a lisp (can't remember which,
Mumath was a language built on top of mulisp, basically it was mulisp with infix syntax. Mumath was used to implement the computer algebra system musimp.
> or what happened to mumath).
Musimp has been rewritten in mulisp, and now is called Derive. It lives as a cheap computer algebra system for windows and as the engine of some TI calculators.
> I'm always interested in how people "came to something." In this > case it's Lisp. How about relaying how you "came to Lisp?"
Good idea. These stories are interesting!
At the school computer club, me and two other guys were interested in computer languages. This was a problem, since the only language we had was BASIC (on the TRS-80, mostly). So we learned assembly language, and read books on various languages, and designed our own language, mostly based on APL, which we thought was really powerful - but we never got started on implementing it.
One day, another kid, Orri Erling, comes in, and he's written a Lisp interpreter in Z80 assembly. That was quite impressive, even though not practical to use, as he never quite finished the system, having found something more interesting to do. So grade 10 (3rd-to-last) was when I got the idea that Lisp was the coolest language to play with. I must've read some book on it at this time, but I don't remember which.
Later, we went to various Universities, but kept in touch with Orri who was a couple of years younger than us. He developed this plan for "taking over the world" by writing a better database management system - in Lisp, naturally - and wanted to start a company. When he asked the three of us to join, we were excited and said "Sure!" This was before Oracle, so it made some sense.
By this time, Orri's Lisp interpreter had been ported to 8086 assembly and Pascal, so I started hacking that, and really learned Lisp. Eventually, we'd port it to 80186, 80286, 386 and 486, rewrite the whole thing to make to make it CL-compliant (and to Do It Right), and build a compiler, and never get to market with the DBMS. So we sold the Lisp instead (mostly in Finland, as Mikko Lisp and ES-Lisp and the new implementation as ECL). Not succesfully, I might add.
So, I basically learned Lisp by hacking Lisp implementations. I don't think I ever took a class in Lisp. Taught a couple, though: for the computer club at the old school and filling in at a vocational school. -- Pekka P. Pirinen "Truth is stranger than fiction because fiction has to make sense." - Steve Smith <sgs_grebyn.com>
>> In article <sfwk7re88br....@shell01.TheWorld.com>, Kent M Pitman >> <pit...@world.std.com> wrote:
>> > Erik Naggum <e...@naggum.net> writes: >> > ... >> > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
>> > This seems to me a simple matter of proper education. I doubt it's a >> > fundamental property of the universe.
>> That's a pretty arrogant thing to say. As someone who writes Scheme code >> in Common Lisp (apparently) I take umbrage at your claim that 1) this is >> self-evidently the wrong thing to do and 2) that I do so because I haven't >> had a "proper education".
>I think we're talking about different things.
>I was taking the remark more literally. People really do things like:
> (defun f (x) > (defun g (x) ...) > ... use g ...)
>This kind of thing works in Scheme but doesn't mean what Scheme people >think in CL.
>Certainly there are compatible styles one can adopt, but one can also try >to pretend CL has Scheme semantics and get in trouble.
>Even just relying on tail calling when you've been told it's not reliably >there in CL is an example.
We are talking about a real novice here, who should be given _some_ learning time before being tested. It is quite easy for a person, even a Schemer, to learn that DEFUN doesn't act like an "internal DEFINE" (indeed, quite a few Schemers such as me abjure the use of internal DEFINEs in their own language, preferring to use a more explicitly lexicalizing operator like LET or LETREC); or that tail-call elimination is not guaranteed in CL. A Schemer would in fact be very alive to this, and make sure that he got his lexicals and loops right in the CL environment. All novice problems should be so easily self-correctable.
I think a much more pervasive and uncorrectable malaise is intended when the bad influence of Scheme is cited.
*
To those who do want to write Scheme in CL, may I suggest that if the reason is to simply have your code run in CL, you are better off writing Scheme in Scheme and then using something like http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html -- less stylistic nerves (your own and your CL-knowing critic's) may be frayed that way.
* Dorai Sitaram | All novice problems should be so easily self-correctable.
Would that that were true. The problem is that they are not.
| I think a much more pervasive and uncorrectable malaise is intended when | the bad influence of Scheme is cited.
Somehow, a Scheme freak believes that Scheme is "right" and whatever else he has to do to make things work is "wrong", and therefore never learns what is right in any other language that does not very forcefully prove him fundamentally wrong. It is much harder to make someone believe they are wrong when they are right some of the time than none of the time.
/// -- In a fight against something, the fight has value, victory has none. In a fight for something, the fight is a loss, victory merely relief.
In article <a96mq8$ak...@news.gte.com>, d...@gte.com wrote: > To those who do want to write Scheme in CL, may I > suggest that if the reason is to simply have your code > run in CL, you are better off writing Scheme in Scheme > and then using something like > http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html -- > less stylistic nerves (your own and your > CL-knowing critic's) may be frayed that way.
FWIW, my reason for writing Scheme in CL (if indeed that is what I'm doing) is that IMO it is much easier to write Scheme in CL than it is in Scheme.
> It seems that getting over Scheme can be a difficult task.
i am sceptical. it is only a programming language, and in a very large majority of young programmers, not even close to being the first language; that it itself may lessen its (claimed) impact. moreover, what is it that is so important, so sticky and hard to relearn? what is the real claim about learning? what is the claim about cognition? is the claim supportable? is this sapir/worf rearing its head again? it is so much fun to bash basic, perl, scheme or whatever we hate today, but the actual cognitive effects of learning these languages are not properly studied, so far as i know. one may as well claim that those who learn french or turkish are forever damaged to ever do good lisp programming... :-/
this stuff is all very muddled.
oz -- it seems so long and so many parentheses ago... -- thomas a. russ
* g...@jpl.nasa.gov (Erann Gat) | FWIW, my reason for writing Scheme in CL (if indeed that is what I'm | doing) is that IMO it is much easier to write Scheme in CL than it is in | Scheme.
If true, this explains why Scheme freaks so seldom learn Common Lisp well. Common Lisp would just be a "better Scheme" to them, and just like C programmers keep programming in C forever because all the "modern" languages all have a basic C-like syntax. Perhaps a significant change in the syntax is _necessary_ to make people change their habits, as they would no longer be visually tempted to think it is the same as they know.
/// -- In a fight against something, the fight has value, victory has none. In a fight for something, the fight is a loss, victory merely relief.
> FWIW, my reason for writing Scheme in CL (if indeed that is what I'm > doing) is that IMO it is much easier to write Scheme in CL than it is in > Scheme.
Perhaps you are using only that subset of Scheme which is not painful to write in CL...You Outcast :)
It be interesting to know if you were using a kind of Scheme + CL extensions that was langauge focused or "just" library focused. I.e., whether it was Scheme subset + CLOS (in which case, a Scheme + GOOPS might work for you) or Scheme subset + format. Etc.
Erann Gat <g...@jpl.nasa.gov> wrote: >In article <a96mq8$ak...@news.gte.com>, d...@gte.com wrote:
>> To those who do want to write Scheme in CL, may I >> suggest that if the reason is to simply have your code >> run in CL, you are better off writing Scheme in Scheme >> and then using something like >> http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html -- >> less stylistic nerves (your own and your >> CL-knowing critic's) may be frayed that way.
>FWIW, my reason for writing Scheme in CL (if indeed that is what I'm >doing) is that IMO it is much easier to write Scheme in CL than it is in >Scheme.
It's clear you are not one who'd use internal DEFUN or assume tail-call elimination or commit any of the other boo-boos alleged of those who have learned Scheme before CL. So if all you are saying is that you like to use values directly instead of always indirecting through symbols bound to them, I don't think that marks you as someone who "writes Scheme in CL".
I am sure CL usage is quite accepting and encouraging even of the direct manipulation of values. I'd be surprised if there were even a tacit stylistic admonition against it.
