Racket is a descendant of Scheme. How is Racket different than R6RS? What did it add, or take away, or is just different?

I understand that Racket is more than a language, it&#39;s a platform for languages. But I&#39;m referring to the main Racket dialect.

How is Racket different from Scheme?

I have been programming in Python, PHP, Java and C for a couple or years now, and I just finished reading Hackers and Painters, so I would love to give LISP a try!

I understand its totally diferent from what i know and that it won&#39;t be easy. Also I think (please correct me if I&#39;m wrong) there&#39;s way less community and development around LISP. So my question is: what&#39;s the best way to learn LISP?

I wouldn&#39;t mind buying books or investing some time. I just don&#39;t want it to be wasted.

The &quot;final&quot; idea would be to use LISP for web development, and I know that&#39;s not so common so... I know it&#39;s good to plan my learning before picking the first book or tutorial and spending lots of time on something that may not be the best way! 

Thank you all for your answers!

**edit:** I read Practical Common Lisp and was: ... long, hard, interesting and definitely got me rolling in Lisp, after that i read the little schemer, and it was short, fun and very very good for my overall programming. So my recommendation would be to read first the little schemer, then (its a couple of hours and its worth it) if you decide lisp(or scheme or whatever dialect) is not what you where looking for, you will still have a very fun new way of thinking about recursion!

What&#39;s the best way to learn LISP?

I need some help understanding some of the points from Paul Graham’s [What Made Lisp Different][1].

1. A new concept of variables. In Lisp, all variables are effectively pointers. Values are what have types, not variables, and assigning or binding variables means copying pointers, not what they point to.

2. A symbol type. Symbols differ from strings in that you can test equality by comparing a pointer.

3. A notation for code using trees of symbols.

4. The whole language always available. There is no real distinction between read-time, compile-time, and runtime. You can compile or run code while reading, read or run code while compiling, and read or compile code at runtime.

What do these points mean? How are they different in languages like C or Java? Do any other languages other than Lisp family languages have any of these constructs now?


  [1]: http://www.paulgraham.com/diff.html

Please explain some of Paul Graham&#39;s points on Lisp

I have experimented with Lisp (actually Scheme) and found it to be a very beautiful language that I am interested in learning more about.  However, it appears that Lisp is never used in serious projects, and I haven&#39;t seen it listed as a desired skill on any job posting.  I am interested in hearing from anyone who has used Lisp or seen it used in the &quot;real world&quot;, or who knows whether it is considered a purely academic language.

Lisp in the real world

I know that Lisp and Scheme programmers usually say that `eval` should be avoided unless strictly necessary. I’ve seen the same recommendation for several programming languages, but I’ve not yet seen a list of clear arguments against the use of `eval`. Where can I find an account of the potential problems of using `eval`?

For example, I know the problems of `GOTO` in procedural programming (makes programs unreadable and hard to maintain, makes security problems hard to find, etc), but I’ve never seen the arguments against `eval`.

Interestingly, the same arguments against `GOTO` should be valid against continuations, but I see that Schemers, for example, won’t say that continuations are &quot;evil&quot; -- you should just be careful when using them. They’re much more likely to frown upon code using `eval` than upon code using continuations (as far as I can see -- I could be wrong).

Why exactly is eval evil?

I know they are dialects of the same family of language called lisp, but what exactly are the differences? Could you give an overview, if possible, covering topics such as syntax, characteristics, features and resources.

What are the differences between Clojure, Scheme/Racket and Common Lisp?

I have a passing knowledge of other Lisps (particularly Scheme) from way back. Recently I&#39;ve been reading about [Clojure](http://clojure.org/). I see that it has both &quot;symbols&quot; and &quot;keywords&quot;. Symbols I&#39;m familiar with, but not with keywords.

Do other Lisps have keywords? How are keywords different from symbols other than having different notation (ie: colons)?

Why does Clojure have &quot;keywords&quot; in addition to &quot;symbols&quot;?

A phrase that I&#39;ve noticed recently is the concept of &quot;point free&quot; style...

First, there was [this][1] question, and [also this one][2].

Then, I discovered [here][3] they mention &quot;Another topic that may be worth discussing is the authors&#39; dislike of point free style.&quot;

What is &quot;point free&quot; style? Can someone give a concise explanation? Does it have something to do with &quot;automatic&quot; currying?

To get an idea of my level - I&#39;ve been teaching myself Scheme, and have written a simple Scheme interpreter... I understand what &quot;implicit&quot; currying is, but I don&#39;t know any Haskell or ML.


  [1]: https://stackoverflow.com/questions/943405/point-free-style-with-objects-records-in-f
  [2]: https://stackoverflow.com/questions/907306/confusion-about-currying-and-point-free-style-in-haskell
  [3]: http://lambda-the-ultimate.org/node/3331

What is &quot;point free&quot; style (in Functional Programming)?

The intent of my question is **not** to start a flame war, but rather to determine in what circumstances each language is &quot;the best tool for the job.&quot;

I have read several books on Clojure ([Programming Clojure][1], [Practical Clojure][2], [The Joy of Clojure][3], and the Manning Early Access edition of [Clojure in Action][4]), and I think it is a fantastic language. I am currently reading [Let Over Lambda][5] which mostly deals with Common Lisp macros, and, it too, is a very interesting language.

I am **not** a Lisp expert (more of a newbie), but this family of languages fascinates me, as does functional programming, in general.

**Advantages of Clojure** (and disadvantages of &quot;others&quot;):

 - Runs on the JVM.
  - The JVM is a very stable, high-performance language environment that pretty well meets Sun&#39;s dream of &quot;Write once, run [almost] anywhere&quot;. I can write code on my Macbook Pro, compile it into an executable JAR file, and then run it on Linux and Microsoft Windows with little additional testing.

  - The (Hotspot, and other) JVM supports high-quality garbage collection and very performant just-in-time compilation and optimization. Where just a few years ago, I wrote everything that had to run fast in C, now I do not hesitate to do so in Java.

  - Standard, simple, multithreading model. Does Common Lisp have a standard multithreading package?

  - Breaks up the monotony of all those parentheses with `[]`, `{}`, and `#{}`, although Common Lisp experts will probably tell me that with reader macros, you can add those to CL.

**Disadvantages of Clojure**:

 - Runs on the JVM.
  - No tail recursion or continuations. Does Common Lisp support continuations? Scheme requires support for both, I believe.

**Advantages of Others (Common Lisp, in particular)** (and disadvantages of Clojure):

 - User-definable reader macros.

 - Other advantages?

Thoughts? Other differences?

  [1]: http://www.amazon.com/Programming-Clojure-Pragmatic-Programmers-Halloway/dp/1934356336/ref=sr_1_2?ie=UTF8&amp;qid=1305460278&amp;sr=8-2
  [2]: http://www.amazon.com/Practical-Clojure-Experts-Voice-Source/dp/1430272317/ref=sr_1_3?ie=UTF8&amp;qid=1305460278&amp;sr=8-3
  [3]: http://www.amazon.com/Joy-Clojure-Thinking-Way/dp/1935182641/ref=sr_1_1?ie=UTF8&amp;qid=1305460278&amp;sr=8-1
  [4]: http://www.amazon.com/Clojure-Action-Amit-Rathore/dp/1935182595/ref=sr_1_4?ie=UTF8&amp;qid=1305460278&amp;sr=8-4
  [5]: http://www.amazon.com/Let-Over-Lambda-Doug-Hoyte/dp/1435712757/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1305460578&amp;sr=8-1

Clojure vs other Lisps

I wonder what the difference is between those operations in Scheme. I have seen similar questions in Stack Overflow but they are about Lisp, and there is not a comparison between three of those operators.

I am writing the different types of commands in Scheme, and I get the following outputs:

    (eq? 5 5) --&gt;#t
    (eq? 2.5 2.5) --&gt;#f
    (equal? 2.5 2.5) --&gt; #t
    (= 2.5 2.5) --&gt; #t

Why is this the case?

What is the difference between eq?, eqv?, equal?, and = in Scheme?

*Note: I am not asking which to learn, which is better, or anything like that.*

I picked up the free version of SICP because I felt it would be nice to read (I&#39;ve heard good stuff about it, and I&#39;m interested in that sort of side of programming). 

I know Scheme is a dialect of Lisp and I wondered: what is the actual difference is between Scheme and, say, Common Lisp?

 There seems to be a lot about &#39;CL has a larger stdlib...Scheme is not good for real-world programming..&#39; but no actual thing saying &#39;this is because CL is this/has this&#39;.

What are the actual differences between Scheme and Common Lisp? (Or any other two dialects of Lisp)

I am looking for a version of Scheme or even LISP that I can use to recover some lost Lisp development skills.  Some web capabilities would be nice but not essential. 

I&#39;ve looked at Plt and MIT scheme and, while both look pretty good, the Plt seems to be more feature rich.  I&#39;ve also looked at Lisp implementations but all of the seem quite expensive.

I favor free/inexpensive implementations as this is truly likely to just be occasional hobby programming. What recommendations would you have?

What is the best Scheme or LISP implementation for OS X?

On this site they say there are 10 LISP primitives. 
The primitives are: `atom, quote, eq, car, cdr, cons, cond, lambda, label, apply`.

http://hyperpolyglot.wikidot.com/lisp#ten-primitives 

Stevey reckons there are seven (or five):

&gt; Its part of the purity of the idea of LISP: you only need the seven (or is 
&gt; it five?) primitives to build the full machine.
http://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html 

What is the minimum number of primitives to build a LISP machine (ie something that can run an eval/value function on LISP code)? (And which ones are they?)

(I can understand you could live without `atom, label and apply`)

How many primitives does it take to build a LISP machine? Ten, seven or five?

I usually write web apps in PHP, Ruby or Perl. I am starting the study of Scheme and I want to try some web project with this language. But I can&#39;t find what is the best environment for this.
 
I am looking for the following features:

- A simple way of get the request parameters (something like: get-get #key, get-post #key, get-cookie #key).
- Mysql access.
- HTML Form generators, processing, validators, etc.
- Helpers for filter user input data (something like htmlentities, escape variables for put in queries, etc).
- FLOSS.
- And GNU/Linux friendly.

So, thanks in advance to all replies. 


 

How can I do web programming with Lisp or Scheme?

### Which Lisp (dialect) should I learn, and why?

The fragmentation between CL and Scheme slows uptake (at least for me!).

So, give me the &quot;true answer&quot;, please!

I have tried to read feature comparisons, and they seem to get bogged down in esoterica (that I don&#39;t fully understand) like whether the dialect is fully tail-recursive, and the like.  I&#39;m hoping you all (collectively) can make the opaque differences clear.

### Things I like

Good library support, good environments, and Unicode support.

### Things I dislike

Flamewars. Features that are useful at the beginning, but interfere with long-term learning. 

----

### Updates

  1. I&#39;ve been mostly using MzScheme, which I&#39;m enjoying just fine, once I got readline support going.  I don&#39;t run a GUI on Unix, so it seemed to be a fine environment option for me.

  1. I&#39;m also very happy that Clojure has an easy to install .deb package on debian, so it&#39;s much easier to play with.  This is a big win.  Despite the hostility of some rather easy-to-anger below, low barrier to entry is a win.  I like being spoonfed.

  1. After reading a lot more of [SICP][1], I do understand the issues around tail recursion much better.



  [1]: http://mitpress.mit.edu/sicp/

Which Lisp should I learn?

I have been using [PLT Scheme][1], but it has some issues. Does anyone know of a better implementation for working through SICP?


  [1]: http://www.plt-scheme.org/

What is the best Scheme implementation for working through SICP?

To begin, not only are there two main dialects of the language (Common Lisp and Scheme), but each of the dialects has many individual implementations. For example, Chicken Scheme, Bigloo, etc... each with slight differences. 

From a modern point of view this is strange, as languages these days tend to have definitive implementations/specs. Think Java, C#, Python, Ruby, etc, where each has a single definitive site you can go to for API docs, downloads, and such. Of course Lisp predates all of these languages. But then again, even C/C++ are standardized (more or less).

Is the fragmentation of this community due to the age of Lisp? Or perhaps different implementations/dialects are intended to solve different problems? I understand there are good reasons why Lisp will never be as united as languages that have grown up around a single definitive implementation, but at this point is there any good reason why the Lisp community should not move in this direction?

Why is the Lisp community so fragmented?

I come across the word &#39;thunk&#39; at a lot of places in code and documentation related to Scheme, and similar territories. I am guessing that it is a generic name for a procedure, which has a single formal argument. Is that correct? If yes, is there more to it? If no, please?

For eg. in [SRFI 18][1], in the &#39;Procedures&#39; section.


  [1]: http://srfi.schemers.org/srfi-18/srfi-18.html

What is a &#39;thunk&#39;, as used in Scheme or in general?

I&#39;ve been getting more into Lisp and Lispy languages lately, and I&#39;m finding them quite powerful.

One thing I&#39;ve been reading all over the net is that a benefit of writing in Lisp, Clojure, etc, is that you can edit your program &quot;while it&#39;s running&quot;.

Perhaps I&#39;m missing something, but what is the point?

Sure, it might save a few seconds, but is that all?  Whenever I make a change to my program I just stop it then start it again, and that has been working fine for decades.

There must be a reason other than just saving time -- what is it?

Can someone give me a good case study that will make me drool over this feature? :)

Looking forward to drooling!

Editing programs &quot;while they are running&quot;? Why?

I am on day 1 hour 1 of teaching myself Scheme.  Needless to say, I don&#39;t understand anything. So I&#39;m reading _The Little Schemer_ and using this thing:

&gt; http://sisc-scheme.org/sisc-online.php

as an interpreter. 

I need to use `&#39;` in for example

    (atom? &#39;turkey)

to avoid an &quot;undefined variable&quot; error.  The `&#39;`, according to the book, is a Common Lisp thing. 

I have two questions:

1. Is the interpreter I mentioned above a good one? Can you recommend another?  I need one that will go well with _The Little Schemer_.

2. What is `&#39;`?

What is &#39; (apostrophe) in Lisp / Scheme?

I&#39;ve tried several times to grasp the concept of [continuations][1] and [call/cc][2]. Every single attempt was a failure. Can somebody please explain me these concepts, ideally with more realistic examples than these on Wikipedia or in other SO posts.

I have background in web programming and OOP. I also understand 6502 assembly and had a minor randez-vous with Erlang. However still, I can&#39;t wrap my head around call/cc.


  [1]: http://en.wikipedia.org/wiki/Continuation
  [2]: http://en.wikipedia.org/wiki/Call-with-current-continuation

What is call/cc?

How useful is the feature of having an atom data type in a programming language?

A few programming languages have the concept of atom or symbol to represent a constant of sorts. There are a few differences among the languages I have come across (Lisp, Ruby and Erlang), but it seems to me that the general concept is the same. I am interested in programming language design, and I was wondering what value does having an atom type provide in real life. Other languages such as Python, Java, C# seem to be doing quite well without it.

I have no real experience of Lisp or Ruby (I know the syntaxes, but haven&#39;t used either in a real project). I have used Erlang enough to be used to the concept there.

Lisp and Erlang Atoms, Ruby and Scheme Symbols. How useful are they?

I want to install [MIT Scheme][1] on my Mac, I have downloaded the *MacOS X binary(x86-64)*.

However, I could not make it work using Mac Terminal.

I have tried to follow these articles:

[Installing MIT/GNU Scheme on Mac OS X Leopard][2]

&lt;s&gt;[Installing MIT Scheme on Mac OS X][3]&lt;/s&gt;

but it seems out of date and does not work.

So, I&#39;m looking for a simple method which allows me to write Scheme code using Mac Terminal.

I have struggled for hours to try to install it.

  [1]: http://www.gnu.org/software/mit-scheme/
  [2]: http://renevanbelzen.wordpress.com/2008/11/13/installing-mitgnu-scheme-on-mac-os-x-leopard/
  [3]: https://wiki.umn.edu/CSCI1901/InstallingMITScheme

How to install MIT Scheme on Mac?

What are the popular (ok, popular is relative) web frameworks for the various flavours of LISP?

Lisp Web Frameworks?

I am very very interested in Macros and just beginning to understand its true power. Please help me collect some great usage of macro systems. 

So far I have these constructs: 

**Pattern Matching:**

&gt; Andrew Wright and Bruce Duba. Pattern
&gt; matching for Scheme, 1995

**Relations in the spirit of Prolog:**

&gt; Dorai Sitaram. Programming in schelog.
&gt; http://www.ccs.neu.edu/home/dorai/schelog/schelog.html
&gt; 
&gt; Daniel P. Friedman, William E. Byrd,
&gt; and Oleg Kiselyov. The Reasoned
&gt; Schemer. The MIT Press, July 2005
&gt; 
&gt; Matthias Felleisen. Transliterating
&gt; Prolog into Scheme. Technical Report
&gt; 182, Indiana University, 1985.

    
**Extensible Looping Constructs:**

&gt; Sebastian Egner. Eager comprehensions
&gt; in Scheme: The design of SRFI-42. In
&gt; Workshop on Scheme and Functional
&gt; Programming, pages13–26, September
&gt; 2005.
&gt; 
&gt; Olin Shivers. The anatomy of a loop: a
&gt; story of scope and control. In
&gt; International Conference on Functional
&gt; Programming, pages 2–14, 2005.

     
**Class Systems:**

&gt; PLT. PLT MzLib: Libraries manual.
&gt; Technical Report PLT-TR2006-4-v352,
&gt; PLT Scheme Inc., 2006.
&gt; http://www.plt-scheme.org/techreports/
&gt; 
&gt; Eli Barzilay. Swindle.
&gt; http://www.barzilay.org/Swindle.

   
**Component Systems:**

&gt; Ryan Culpepper, Scott Owens, and
&gt; Matthew Flatt. Syntactic abstraction
&gt; in component interfaces. In
&gt; International Conference on Generative
&gt; Programming and Component Engineering,
&gt; pages 373–388, 2005

**Software Contract Checking**

&gt; Matthew Flatt and Matthias Felleisen.
&gt; Units: Cool modules for HOT languages
&gt; In ACM SIGPLAN Conference on
&gt; Programming Language Design and
&gt; Implementation, pages 236–248, 1998
&gt; 
&gt; Oscar Waddell and R. Kent Dybvig.
&gt; Extending the scope of syntactic
&gt; abstraction.In Symposium on Principles
&gt; of Programming Languages, pages
&gt; 203–215, 199

**Parser Generators**

&gt; Scott Owens, Matthew Flatt, Olin
&gt; Shivers, and Benjamin McMullan. Lexer
&gt; and parser generators in Scheme. In
&gt; Workshop on Scheme and Functional
&gt; Programming, pages 41–52, September
&gt; 2004.

**Tools for Engineering Semantics:**

&gt; Matthias Felleisen, Robert Bruce
&gt; Findler, and Matthew Flatt. Semantics
&gt; Engineering with PLT Redex. MIT Press,
&gt; August 2009.

 
**Speciﬁcations of Compiler Transformations:**

&gt; Dipanwita Sarkar, Oscar Waddell, and R. Kent Dybvig. A nanopass
&gt; framework for compiler education.
&gt; Journal of Functional
&gt; Programming,15(5):653–667, September
&gt; 2005. Educational Pearl.

      
**Novel Forms of Execution**

&gt; Servlets with serializable
&gt; continuations Greg Pettyjohn, John
&gt; Clements, Joe Marshall, Shriram
&gt; Krishnamurthi, and Matthias Felleisen.
&gt; Continuations from generalized stack
&gt; inspection. In International
&gt; Conference on Functional Programming,
&gt; pages216–227, 2005.

   
**Theorem-Proving System**

&gt; Sebastian Egner. Eager comprehensions in Scheme: The design
&gt; of  SRFI-42.
&gt; In Workshop on Scheme and Functional Programming, pages 13–26,
&gt; September 2005.

**Extensions of the Base Language with Types**

&gt; Sam Tobin-Hochstadt and Matthias
&gt; Felleisen.The design and
&gt; implementation of typed scheme. In
&gt; Symposium on Principles of Programming
&gt; Languages, pages 395–406, 2008.

    
**Laziness**

&gt; Eli Barzilay and John Clements.
&gt; Laziness without all the hard
&gt; work:combining lazy and strict
&gt; languages for teaching. In Functional
&gt; and declarative programming in
&gt; education, pages 9–13, 2005.

**Functional Reactivity**

&gt; Gregory H. Cooper and Shriram
&gt; Krishnamurthi. Embedding dynamic 
&gt; dataﬂow in a call-by-value language. 
&gt; In European Symposium on Programming,
&gt; 2006

------------------------------------------------

**Reference:** 

Collected from [Ryan Culpepper&#39;s Dissertation](http://www.ccs.neu.edu/scheme/pubs/dissertation-culpepper.pdf)


Collection of Great Applications and Programs using Macros

I know that you can use `&#39;` (aka `quote`) to create a list, and I use this all the time, like this:

    &gt; (car &#39;(1 2 3))
    1

But it doesn’t always work like I’d expect. For example, I tried to create a list of functions, like this, but it didn’t work:

    &gt; (define math-fns &#39;(+ - * /))
    &gt; (map (lambda (fn) (fn 1)) math-fns)
    application: not a procedure;
      expected a procedure that can be applied to arguments
      given: &#39;+

When I use `list`, it works:

    &gt; (define math-fns (list + - * /))
    &gt; (map (lambda (fn) (fn 1)) math-fns)
    &#39;(1 -1 1 1)

Why? I thought `&#39;` was just a convenient shorthand, so why is the behavior different?

What is the difference between quote and list?

I like to study languages outside my comfort zone, but I&#39;ve had a hard time finding a place to start for functional languages.  I heard a lot of good things about [Structure and Interpretations of Computer Programs][1], but when I tried to read through it a couple of years ago it just seemed to whiz over my head.  I do way better with books than web sites, but when I visit the local book store the books on LISP look kind of scary.


So what&#39;s a good starting point?  My goal is to be able to use a functional programming language to solve simple problems in 6 months or so, and the ability to move to more advanced topics, recognize when a functional language is the right tool for the job, and use the language to solve more problems over the course of 2-3 years.  I like books that are heavy on examples but also include challenges to work through.  Does such a thing exist for functional languages?

  [1]: http://www.amazon.com/Structure-Interpretation-Computer-Programs-Second/dp/0070004846/ref=pd_bbs_7?ie=UTF8&amp;s=books&amp;qid=1219429954&amp;sr=8-7

What&#39;s a good beginning text on functional programming?

For the love of the almighty I have yet to understand the purpose of the symbol `&#39;iamasymbol`. I understand numbers, booleans, strings... variables. But symbols are just too much for my little imperative-thinking mind to take. What exactly do I use them for? How are they supposed to be used in a program? My grasp of this concept is just fail.

What exactly is a symbol in lisp/scheme?

I&#39;m working on a Scheme interpreter written in C. Currently it uses the C runtime stack as its own stack, which is presenting a minor problem with implementing continuations. My current solution is manual copying of the C stack to the heap then copying it back when needed. Aside from not being standard C, this solution is hardly ideal.

What is the simplest way to implement continuations for Scheme in C?

How to implement continuations?

Could somebody explain what an &quot;improper list&quot; is?

**Note**:  Thanks to all ! All you guys rock!



Functional Programming: what is an &quot;improper list&quot;?

I have just started to study computer sciences at my university where they teach us programming in Scheme.
 
Since I have learned C++ for the last 6 years, Scheme appears a little odd to me.  My instructors tell me you can write any program you can write in C or Java with it. 

Is anybody really using this language?

Are there people using the Scheme programming language out there?

I want to type something like &#39;scheme file.scm&#39; and have it interpret the file, and then take me back to my shell, rather than loading it in the REPL.


edit: I tried scheme &lt; test.scm and it still uses the REPL, the only difference is that scheme exits when the stream ends.  

All Scheme Solutions on Gang of Coders

Total of 32 Scheme Solutions

How is Racket different from Scheme?

What's the best way to learn LISP?

Please explain some of Paul Graham's points on Lisp