blocks|key|1407691|text|编写Lisp代码。真正“掌握”Lisp+(或任何语言)的唯一方法就是卷起袖子，在其中实现一些东西。就像其他任何东西一样，你可以阅读任何你想要的东西，但如果你想真正地掌握正在发生的事情，你必须跳出理论，开始实践。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1407692|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Write Lisp code. The only way to really 'get' Lisp (or any language, for that matter) is to roll up your sleeves and implement some things in it. Like anything else, you can read all you want, but if you want to really get a firm grasp on what's going on, you've got to step outside the theoretical and start working with the practical.

blocks|key|1085908|text|我认为你必须对编译器编写者有更多的同理心，才能理解代码是数据的基础是什么。我承认，我从来没有上过编译器课程，但是将任何高级语言转换成机器代码都是一个困难的问题，而LISP在许多方面类似于这个过程中的中间步骤。与C“接近金属”的方式一样，LISP也接近编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1085909|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think you have to have more empathy for compiler writers to understand how fundamental the code is data thing is. I'll admit, I've never taken a compilers course, but converting any sufficiently high-level language into machine code is a hard problem, and LISP, in many ways, resembles an intermediate step in this process. In the same way that C is "close to the metal", LISP is close to the compiler.

blocks|key|105470|text|数据即代码是一个有趣的范例，它支持将数据结构视为命令。以这种方式处理数据允许您以各种方式处理和操作结构-例如遍历-通过评估它。此外，“数据就是代码”模式在许多情况下避免了为数据结构开发定制解析器的需要；语言解析器本身可以用于解析结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|105471|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Data is code is an interesting paradigm that supports treating a data structure as a command. Treating data in this way allows you to process and manipulate the structure in various ways - e.g. traversal - by evaluating it. Moreover, the 'data is code' paradigm obviates the need in many cases to develop custom parsers for data structures; the language parser itself can be used to parse the structures.

blocks|key|1086031|text|我认为“代码就是数据”最好的部分是函数在功能上与另一个变量没有什么不同。您可以编写编写代码的代码这一事实是Lisp最强大(但经常被忽视)的特性之一。函数可以接受其他函数作为参数，甚至返回函数作为结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086032|这使得代码具有比Java更高的抽象级别。它使许多任务变得优雅而简洁，从而使代码更易于修改、维护和阅读，至少在理论上是这样。|1086033|我要说的是，真正“掌握”Lisp的唯一方法是花大量时间使用它--一旦您掌握了它的诀窍，您就会希望在其他编程语言中具有Lisp的一些特性。|1086034|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The way I think about it is that the best part of "code is data" is the face that function are, well, functionally no different than another variable. The fact that you can write code that writes code is one of the single most powerful (and often overlooked) features of Lisp. Functions can accept other functions as parameters, and even return functions as a result.

This lets one code at a much higher level of abstraction than, say, Java. It makes many tasks elegant and concise, and therefore, makes the code easier to modify, maintain, and read, or at least in theory.

I would say that the only way to truly "get" Lisp is to spend a lot of time with it -- once you get the hang of it, you'll wish you had some of the features of Lisp in your other programming languages.

blocks|key|106530|text|重要的是要看到数据是代码，代码是数据。这将提供eval/apply循环。递归也很有趣。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|106531|(此链接已断开：|106532|106533|blockquote|106534|106535|1：http://ely.ath.cx/~piranha/random_images/lolcode-eval_apply-2.jpg|offset|length|106536|106537|)|106538|entityMap|0|LINK|mutability|MUTABLE|url|http://ely.ath.cx/~piranha/random_images/lolcode-eval_apply-2.jpg^0|0|0|0|0|0|2|1T|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|E|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@$J|12|K|13|1|14]]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

it's important to see that data is code AND code is data. This feeds the eval/apply loop. Recursion is also fun.

(This link is broken:

<blockquote>
 ![Eval/Apply][1]
 
 [1]: <a href="http://ely.ath.cx/~piranha/random_images/lolcode-eval_apply-2.jpg" rel="nofollow noreferrer">http://ely.ath.cx/~piranha/random_images/lolcode-eval_apply-2.jpg</a>
</blockquote>

)

blocks|key|105540|text|我认为这是一个可怕的语言入门。比起你引用的那本书，有更好的起点和更好的人/文章/书。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|105541|你是程序员吗？使用哪种语言？|105542|为了帮助你回答你的问题，更多的背景可能会有所帮助。|105543|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I'd suggest that is a horrible introduction to the language. There are better places to start and better people/articles/books than the one you cited.

Are you a programmer? What language(s)?

To help you with your question more background might be helpful.

blocks|key|1086137|text|一些大学计算机科学专业使用Lisp进行入门课程的原因之一是，新手学习函数式编程、过程化编程或面向对象编程的效果大体上是一样好的。然而，对于已经在过程性语句中思考的人来说，开始像函数式程序员一样思考要比反其道而行之难得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086138|当我尝试学习Lisp语言时，我是“带着C口音”去学的，set!和begin是我的朋友和忠实的伙伴。不用编写任何函数代码就可以编写Lisp代码，这非常容易，这不是重点。|offset|length|style|CODE|1086139|你可能注意到我没有回答你的问题，这是真的。我只是想让你知道，用函数式风格思考是非常困难的，从长远来看，这将是一种令人兴奋的实践，它将使你成为一名更强大的程序员。|1086140|坎帕伊！|1086141|另外，你最终会明白“我的另一辆车是一辆cdr”的保险杠贴纸。|1086142|entityMap^0|0|R|4|W|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

One of the reasons that some university computer science programs use Lisp for their intro courses is that it's generally true that a novice can learn functional, procedural, or object-oriented programming more or less equally well. However, it's much harder for someone who already thinks in procedural statements to begin thinking like a functional programmer than to do the inverse.

When I tried to pick up Lisp, I did it "with a C accent." <code>set!</code> amd <code>begin</code> were my friends and constant companions. It is surprisingly easy to write Lisp code without ever writing any functional code, which isn't the point.

You may notice that I'm not answering your question, which is true. I merely wanted to let you know that it's awfully hard to get your mind thinking in a functional style, and it'll be an exciting practice that will make you a stronger programmer in the long run.

Kampai!

P.S. Also, you'll finally understand that "my other car is a cdr" bumper sticker.

blocks|key|4303131|text|“掌握”任何一种语言的方法就是尝试用它编写一些代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4303132|关于“数据就是代码”这件事，在大多数语言中，被执行的代码和被处理的数据之间有明显的分离。|4303133|例如，下面这个简单的类似C的函数：|4303134|void+foo(int+i){
++int+j;

++if+(i+%25+42+==+0){
++++bar(i-2);
++}

++for+(j+=+0;+j+<+i;+%2B%2Bj){
++++baz();
++}
}|code-block|syntax|javascript|4303135|实际的控制流在编写代码时静态地确定一次。函数bar不会改变，函数开头的if语句也不会消失。这段代码不是数据，它不能被程序操纵。|offset|length|style|CODE|4303136|可以操作的只有i的初始值。另一方面，该值不能像代码那样执行。您可以调用函数foo，但不能调用变量i。所以i是数据，但它不是代码。|4303137|Lisp没有这种区别。程序代码也是可以操作的数据。您的代码可以在运行时接受函数foo，也许可以添加另一个if语句，也许可以更改for循环中的条件，也许可以用另一个函数调用替换对baz的调用。您的所有代码都是可以检查和操作的数据，就像上面的函数可以检查和操作整数i一样。|4303138|entityMap^0|0|0|0|0|M|3|0|7|1|11|3|1C|1|1G|1|0|13|3|2G|3|3M|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@$M|14|N|15|O|P]|$M|16|N|17|O|P]|$M|18|N|19|O|P]|$M|1A|N|1B|O|P]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@$M|1D|N|1E|O|P]|$M|1F|N|1G|O|P]|$M|1H|N|1I|O|P]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|V|$]]

The way you "get" any language is by trying to write some code in it.

About the "data is code" thing, in most languages there is a clear separation between the code that gets executed, and the data that is processed.

For example, the following simple C-like function:

<pre class="lang-c prettyprint-override"><code>void foo(int i){
 int j;

 if (i % 42 == 0){
 bar(i-2);
 }

 for (j = 0; j &lt; i; ++j){
 baz();
 }
}
</code></pre>

the actual control flow is determined once, statically, while writing the code. The function <code>bar</code> isn't going to change, and the if statement at the beginning of the function isn't going to disappear. This code is not data, it can not be manipulated by the program.

All that can be manipulated is the initial value of <code>i</code>. And on the other hand, that value can not be executed the way code can. You can call the function <code>foo</code>, but you can't call the variable <code>i</code>. So <code>i</code> is data, but it is not code.

Lisp does not have this distinction. The program code is data that can be manipulated too. Your code can, at runtime, take the function <code>foo</code>, and perhaps add another if statement, perhaps change the condition in the for-loop, perhaps replace the call to <code>baz</code> with another function call. All your code is data that can be inspected and manipulated as simply as the above function can inspect and manipulate the integer <code>i</code>.

blocks|key|1086192|text|通过观看传奇Structure+and+Interpretation+of+Computer+Programs|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1086193|entityMap|0|LINK|mutability|MUTABLE|url|http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures^0|6|1D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

By watching legendary <a href="http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures" rel="noreferrer">Structure and Interpretation of Computer Programs</a>?

blocks|key|1086220|text|我强烈推荐Structure+and+Interpretation+of+Computer+Programs，它实际上使用了scheme，但这是lisp的一种方言。它将通过让你做许多不同的练习来帮助你“获得”lisp，并继续展示lisp是如此有用的一些方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1086221|entityMap|0|LINK|mutability|MUTABLE|url|http://mitpress.mit.edu/sicp/^0|5|1D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I would highly recommend <a href="http://mitpress.mit.edu/sicp/" rel="noreferrer">Structure and Interpretation of Computer Programs</a>, which actually uses scheme, but that is a dialect of lisp. It will help you "get" lisp by having you do many different exercises and goes on to show some of the ways that lisp is so usefull.

blocks|key|1405895|text|关于“代码就是数据”这件事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1405896|这不是因为"von+Neumann+architecture“吗？如果代码和数据位于物理上分离的存储器位置，则数据存储器中的位不能被执行，而程序存储器中的位只能解释为CPU的指令。|offset|length|1405897|我的理解是正确的吗？|1405898|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Von_Neumann_architecture^0|0|6|O|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

About the whole "code is data" thing:

Isn't that due to the "<a href="http://en.wikipedia.org/wiki/Von_Neumann_architecture" rel="nofollow noreferrer">von Neumann architecture</a>"? If code and data were located in physically separate memory locations, the bits in the data memory could not be executed whereas the bits in the program memory could not be interpreted as anything but instructions to the CPU.

Do I understand this correctly?

blocks|key|4303296|text|这对我很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4303297|4303298|读过“小阴谋家”。这是让你在Lisp模式下思考的最短路径(去掉宏)。作为额外的好处，这是一本相对short/fun/inexpensive.|ordered-list-item|4303299|Find的好书/教程，可以让你开始使用宏。我发现“方案编程语言”的第8章是方案的一个很好的起点。|4303300|4303301|http://www.ccs.neu.edu/home/matthias/BTLS/|offset|length|4303302|http://www.scheme.com/tspl3/syntax.html|4303303|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|0|0|0|0|16|0|0|0|13|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|Z|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@$K|12|L|13|1|14]]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|J]]|V|$5|R|S|T|A|$U|N]]]]

This worked for me:

<ol>
<li>Read "The Little Schemer". It's the shortest path to get you thinking in Lisp mode (minus the macros). As a bonus, it's relatively short/fun/inexpensive.</li>
<li>Find a good book/tutorial to get you started with macros. I found chapter 8 of "The Scheme
Programming Language" to be a good starting point for Scheme.</li>
</ol>

<a href="http://www.ccs.neu.edu/home/matthias/BTLS/" rel="noreferrer">http://www.ccs.neu.edu/home/matthias/BTLS/</a>

<a href="http://www.scheme.com/tspl3/syntax.html" rel="noreferrer">http://www.scheme.com/tspl3/syntax.html</a>

blocks|key|1086341|text|要真正理解lisp，您需要编写它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086342|学会热爱car、cdr和cons。不要在可以递归的时候迭代。从编写一些简单的程序开始(阶乘、列表反转、字典查找)，然后逐步发展到更复杂的程序(排序项目集、模式匹配)。|offset|length|style|CODE|1086343|在代码上是数据，数据是代码，在这一点上我不会担心。你最终会理解它的，而且它对学习lisp并不重要。|1086344|entityMap^0|0|4|3|8|3|C|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

To truly grok lisp, you need to write it.

Learn to love <code>car</code>, <code>cdr</code>, and <code>cons</code>. Don't iterate when you can recurse. Start out writing some simple programs (factorial, list reversal, dictionary lookup), and work your way up to more complex ones (sorting sets of items, pattern matching).

On the code is data and data is code thing, I wouldn't worry about it at this point. You'll understand it eventually, and its not critical to learning lisp.

blocks|key|105683|text|第一步是忘记你用所有C和类Pascal语言学到的东西。清空你的大脑。这是最困难的一步。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|105684|然后，很好地介绍一下使用Lisp的编程。不要试图将你所看到的与你事先知道的任何事情联系起来(当你发现自己在这样做时，重复第一步)。我喜欢计算机程序的结构和解释(使用方案)，实用的通用Lisp，人工智能编程的范例，在Lisp中铸造Spels，等等。一定要写出示例。也可以尝试这些练习，但将自己限制在书中学到的结构中。例如，如果您发现自己正在尝试查找一些函数来设置变量或一些类似于for循环的语句，请重复步骤1，然后重新阅读前面的章节，以了解如何在Lisp语言中完成此操作。|offset|length|style|CODE|105685|entityMap^0|0|58|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The first step is forgetting everything you have learned with all the C and Pascal-like languages. Empty your mind. This is the hardest step.

Then, take a good introduction to programming that uses Lisp. Don't try to correlate what you see with anything that you know beforehand (when you catch yourself doing that, repeat step 1). I liked Structure and Interpretation of Computer Programs (uses Scheme), Practical Common Lisp, Paradigms of Artificial Intelligence Programming, Casting Spels in Lisp, among others. Be sure to write out the examples. Also try the exercises, but limit yourself to the constructs you have learned in that book. If you find yourself trying to find, for example, some function to set a variable or some statement that resembles a <code>for</code> loop, repeat step 1, then revisit the chapters before to find out how it is done in Lisp.

blocks|key|1086408|text|这可能是有帮助的：http://www.defmacro.org/ramblings/fp.html+(不是关于LISP的，而是关于函数式编程的范例)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1086409|entityMap|0|LINK|mutability|MUTABLE|url|http://www.defmacro.org/ramblings/fp.html^0|9|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

This may be helpful: <a href="http://www.defmacro.org/ramblings/fp.html" rel="nofollow noreferrer">http://www.defmacro.org/ramblings/fp.html</a> (isn't about LISP but about functional programming as a paradigm)

blocks|key|105719|text|请阅读On+Lisp和Paradigms+in+Artificial+Intelligence+Programming。这两个工具都很好地覆盖了Lisp宏--这使得代码是真实的数据概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|105720|此外，在编写Lisp时，不要在可以递归或映射(学会喜欢mapcar)时进行迭代。|105721|entityMap|0|LINK|mutability|MUTABLE|url|http://www.paulgraham.com/onlisp.html|1|http://norvig.com/paip.html^0|3|7|0|B|1C|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

Read <a href="http://www.paulgraham.com/onlisp.html" rel="nofollow noreferrer">On Lisp</a> and <a href="http://norvig.com/paip.html" rel="nofollow noreferrer">Paradigms in Artificial Intelligence Programming</a>. Both of these have excellent coverage of Lisp macros - which really make the code is data concept real.

Also, when writing Lisp, don't iterate when you can recurse or map (learn to love mapcar).

blocks|key|4303492|text|老式的观点是：'it‘是带有符号表达式的交互计算。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4303493|Lisp支持所有类型的表达式的easy表示：|4303494|英语句子|4303495|(the+man+saw+the+moon)|code-block|syntax|javascript|4303496|数学|4303497|(2+*+x+**+3+%2B+4+*+x+**+2+-+3+*+x+%2B+3)|4303498|规则|4303499|(<-+(likes+Kim+?x)+(likes+?x+Lee)+(likes+?x+Kim))|4303500|还有Lisp本身|4303501|(mapcar+(function+sqr)+(quote+(1+2+3+4+5)))|4303502|还有更多。|4303503|Lisp现在允许用这样表达式编写计算的程序|4303504|(translate+(quote+(the+man+saw+the+moon))+(quote+german))

(solve+(quote+(2+*+x+**+3+%2B+4+*+x+**+2+-+3+*+x+%2B+3))+(quote+(x+.+3)))

(show-all+(quote+(<-+(likes+Kim+?x)+(likes+?x+Lee)+(likes+?x+Kim))))

(eval+(quote+(mapcar+(function+sqr)+(quote+(1+2+3+4+5)))))|4303505|交互性意味着编程是与Lisp的对话。您输入一个表达式，Lisp将计算副作用(例如输出)和值。|4303506|因此，您的编程会话就像是在与Lisp系统“对话”。你会一直使用它，直到你得到正确的答案。|4303507|这些表达式是什么？它们是某种语言中的句子。它们是对涡轮机的部分描述。它们是描述AMD处理器的浮点引擎的定理。它们是物理学中的计算机代数表达式。它们是对电路的描述。它们是游戏中的规则。它们是对游戏中参与者行为的描述。它们是医疗诊断系统中的规则。|4303508|Lisp允许您将事实、规则、公式写成符号表达式。它允许您编写使用这些表达式的程序。您可以计算公式的值。但是您可以同样容易地编写从公式计算新公式的程序(符号数学:+integrate、derive等)。这就是Lisp设计的目标。|4303509|作为一个副作用，Lisp程序也被表示为这样的表达式。然后还有一个Lisp程序，用于评估或编译其他Lisp程序。所以Lisp的思想，符号表达式的计算，已经被应用到Lisp本身，+Lisp程序是符号表达式，计算是Lisp表达式。|4303510|Alan+Kay+(以Smalltalk成名)在Lisp+the+Maxwell's+equations+of+programming中调用了Lisp计算的原始定义。|4303511|entityMap|0|LINK|mutability|MUTABLE|url|http://defmeta.blogspot.com/2007/01/maxwells-equations-of-programming.html^0|K|5|0|0|M|0|0|4|0|0|0|2|0|0|0|2|0|0|0|8|0|0|0|5|0|0|E|G|5|0|0|0|1A|0|0|18|0|0|3D|0|0|35|0|0|2F|0|T|12|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|23|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|U|3|V|5|L|7|27|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|2B|8|@]|D|@]|E|$M|N]]|$1|10|3|11|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|2F|8|@$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]]|D|@]|E|$]]|$1|14|3|15|5|L|7|2K|8|@]|D|@]|E|$M|N]]|$1|16|3|17|5|6|7|2L|8|@$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|18|3|19|5|6|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|2U|8|@$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|30|8|@]|D|@$9|31|A|32|1|33]]|E|$]]|$1|1I|3|-4|5|6|7|34|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1P]]]]

The old fashioned view: 'it' is interactive computation with symbolic expressions.

Lisp enables easy representation of all kinds of expressions:

english sentence

<pre><code>(the man saw the moon)
</code></pre>

math

<pre><code>(2 * x ** 3 + 4 * x ** 2 - 3 * x + 3)
</code></pre>

rules

<pre><code>(&lt;- (likes Kim ?x) (likes ?x Lee) (likes ?x Kim))
</code></pre>

and also Lisp itself

<pre><code>(mapcar (function sqr) (quote (1 2 3 4 5)))
</code></pre>

and many many many more.

Lisp now allows to write programs that compute with such expressions:

<pre><code>(translate (quote (the man saw the moon)) (quote german))

(solve (quote (2 * x ** 3 + 4 * x ** 2 - 3 * x + 3)) (quote (x . 3)))

(show-all (quote (&lt;- (likes Kim ?x) (likes ?x Lee) (likes ?x Kim))))

(eval (quote (mapcar (function sqr) (quote (1 2 3 4 5)))))
</code></pre>

Interactive means that programming is a dialog with Lisp. You enter an expression and Lisp computes the side effects (for example output) and the value.

So your programming session is like 'talking' with the Lisp system. You work with it until you get the right answers.

What are these expressions? They are sentences in some language. They are part descriptions of turbines. They are theorems describing a floating point engine of an AMD processor. They are computer algebra expressions in physics. They are descriptions of circuits. They are rules in a game. They are descriptions of behavior of actors in games. They are rules in a medical diagnosis system.

Lisp allows you to write down facts, rules, formulas as symbolic expressions. It allows you to write programs that work with these expressions. You can compute the value of a formula. But you can equally easy write programs that compute new formulas from formulas (symbolic math: integrate, derive, ...). That was Lisp designed for.

As a side effect Lisp programs are represented as such expressions too. Then there is also a Lisp program that evaluates or compiles other Lisp programs. So the very idea of Lisp, the computation with symbolic expressions, has been applied to Lisp itself. Lisp programs are symbolic expressions and the computation is a Lisp expression.

Alan Kay (of Smalltalk fame) calls the original definition of Lisp evaluation in Lisp <a href="http://defmeta.blogspot.com/2007/01/maxwells-equations-of-programming.html" rel="noreferrer">the Maxwell's equations of programming</a>.

blocks|key|106782|text|我建议检查一些较新的Lisp变体，如Arc或Clojure。它们稍微清理了语法，而且比Common+Lisp更小，更容易理解。Clojure将是我的选择。它是在JVM上编写的，因此您不会遇到像SBCL这样的某些Lisp实现中存在的各种平台实现和库支持的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|106783|entityMap|0|LINK|mutability|MUTABLE|url|http://www.arclanguage.com/|1|http://clojure.org/^0|I|3|0|M|7|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

I would suggest checking out some of the newer variants of Lisp like <a href="http://www.arclanguage.com/" rel="nofollow noreferrer">Arc</a> or <a href="http://clojure.org/" rel="nofollow noreferrer">Clojure</a>. They clean up the syntax a little and are smaller and thus easier to understand than Common Lisp. Clojure would be my choice. It is written on the JVM and so you don't have the issues with various platform implementations and library support that exist with some Lisp implementations like SBCL.

blocks|key|1406098|text|在Common+Lisp中，“代码就是数据”归结起来就是这样。当你写的时候，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1406099|(add+1+2)|code-block|syntax|javascript|1406100|您的Lisp系统将解析该文本并生成一个包含三个元素的列表:符号ADD以及数字1和2。你可以用它们做任何你想做的事情，替换元素，插入其他东西等等。|1406101|有趣的是，您可以将这些数据传递给编译器，因为您可以使用Lisp本身处理这些数据结构，这意味着您可以编写编写其他程序的程序。这并不像听起来那么复杂，Lispers一直使用宏来做这件事。因此，只需获得一本关于Lisp的书，并尝试它。|1406102|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In Common Lisp, "code is data" boils down to this. When you write, for example:

<pre><code>(add 1 2)
</code></pre>

your Lisp system will parse that text and generate a list with three elements: the symbol ADD, and the numbers 1 and 2. So now they're data. You can do whatever you want with them, replace elements, insert other stuff, etc.

The fun part is that you can pass this data on to the compiler and, because you can manipulate these data structures using Lisp itself, this means you can write programs that write other programs. This is not as complicated as it sounds, and Lispers do it all the time using macros. So, just get a book about Lisp, and try it out.

blocks|key|1406116|text|阅读并理解Lisp+1.5+Programmer's+Manual的传奇般的第13页|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1406117|至少在艾伦·凯看来是这样。|1406118|entityMap|0|LINK|mutability|MUTABLE|url|http://books.google.com/books?id=68j6lEJjMQwC&dq=lisp%2Bprogrammers%2Bmanual%2B1.5&printsec=frontcover&source=bn&hl=en&ei=OFxdSvl_kda2A7f5uJwK&sa=X&oi=book_result&ct=result&resnum=4^0|5|S|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Read and understand the legendary page 13 of the <a href="http://books.google.com/books?id=68j6lEJjMQwC&amp;dq=lisp+programmers+manual+1.5&amp;printsec=frontcover&amp;source=bn&amp;hl=en&amp;ei=OFxdSvl_kda2A7f5uJwK&amp;sa=X&amp;oi=book_result&amp;ct=result&amp;resnum=4" rel="nofollow noreferrer">Lisp 1.5 Programmer's Manual</a>
 According to Alan Kay, at least.

blocks|key|106849|text|我认为，要学习任何东西，你都必须有一个目标，比如一个简单的项目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|106850|对于Lisp来说，一个好的简单项目是一种符号区分，例如|106851|(diff+'x+'x)+->+1
(diff+'a+'x)+->+0
(diff+`(%2B+,xx+,yy)+'x)+where+xx+and+yy+are+subexpressions
+->+`(%2B+,(diff+xx+'x),(diff+yy+'x))
etc.+etc.|code-block|syntax|javascript|106852|然后你需要一个简化器，比如|106853|(simp+`(%2B+,x+0))+->+x
(simp+`(*+,x+0))+->+0
etc.+etc.|106854|所以如果你从一个数学表达式开始，你可以求值得到它的值，你可以求导出它的导数。|106855|我希望这说明了当程序代码操纵程序代码时会发生什么。|106856|正如Marvin+Minsky所观察到的，计算机数学总是担心精度和舍入误差，对吧？好吧，这要么完全正确，要么完全错误！|106857|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I think to learn anything you have to have a purpose for it, such as a simple project.

For Lisp, a good simple project is a symbolic differentiator, so for example

<pre><code>(diff 'x 'x) -&gt; 1
(diff 'a 'x) -&gt; 0
(diff `(+ ,xx ,yy) 'x) where xx and yy are subexpressions
 -&gt; `(+ ,(diff xx 'x),(diff yy 'x))
etc. etc.
</code></pre>

and then you need a simplifier, such as

<pre><code>(simp `(+ ,x 0)) -&gt; x
(simp `(* ,x 0)) -&gt; 0
etc. etc.
</code></pre>

so if you start with a math expression, you can eval it to get its value, and you can eval its derivative to get its derivative.

I hope this illustrates what can happen when program code manipulates program code.

As Marvin Minsky observed, computer math is always worried about accuracy and roundoff error, right? Well, this is either exactly right or completely wrong!

blocks|key|4303706|text|您可以通过许多方式获得LISP，最常见的是使用Emacs或与已经开发过LISP的人一起工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4303707|可悲的是，一旦你得了口吃，就很难摆脱它，抗生素不会起作用。|4303708|顺便说一句:我也推荐The+Adventures+of+a+Pythonista+in+Schemeland。|offset|length|4303709|entityMap|0|LINK|mutability|MUTABLE|url|http://www.phyast.pitt.edu/~micheles/scheme/^0|0|0|A|18|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You can get LISP in many ways, the most common is by using Emacs or working next to somebody who has developed LISP already.

Sadly, once you get LISP, it's hard to get rid of it, antibiotics won't work.

BTW: I also recommend <a href="http://www.phyast.pitt.edu/~micheles/scheme/" rel="nofollow noreferrer">The Adventures of a Pythonista in Schemeland</a>.

blocks|key|4303759|text|好的，我要试一试。我自己也是Lisp的新手，刚从python世界来到这里。我还没有经历过所有老Lisper都在谈论的那种突如其来的启蒙时刻，但我会告诉你到目前为止我所看到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4303760|首先，看看这段随机的python代码：|4303761|def+is_palindrome(st):
++++l+=+len(st)/2
++++return+True+if+st[:l]+==+st[:-l-1:-1]+else+False|code-block|syntax|javascript|4303762|现在看看这个：|4303763|"""
def+is_palindrome(st):
++++l+=+len(st)/2
++++return+True+if+st[:l]+==+st[:-l-1:-1]+else+False
"""|4303764|作为一名程序员，你看到了什么？代码是一样的，仅供参考。|4303765|如果你像我一样，你会倾向于认为第一个是活动代码。它由许多语法元素组成。|4303766|第二个，尽管有相似之处，但它是一个单一的句法项目。这是一个字符串。您可以将其作为单个实体进行交互。要将其作为代码来处理--在语法边界上轻松地处理它--您必须进行一些解析。要执行它，您需要调用一个解释器。这和第一次完全不是一回事。|4303767|那么，当我们在大多数语言中进行代码生成时，我们要处理的是什么？字符串。当我使用python生成HTML或SQL时，我使用python字符串作为两种语言之间的接口。即使我用python生成python，字符串也是工具。*|4303768|一想到这是不是就...让你想和joy一起跳舞？在你正在使用的东西和你正在使用的东西之间总是有这种奇怪的不匹配。当我第一次使用perl生成SQL时，我感觉到了这一点。转义的不同。格式上的差异:想一想如何让生成的html文档看起来整洁。这些东西不容易重用。等。|4303769|为了解决这个问题，我们连续创建模板库。他们成群结队。为什么这么多？我的猜测是，它们从来都不是很令人满意。当他们开始变得足够强大的时候，他们已经变成了怪物。诚然，它们中的一些-比如python世界中的SQLAlchemy和Genshi+-是非常美丽和令人钦佩的怪物。让我们..。嗯..。避免提及PHP。|4303770|因为字符串在已处理的语言和已处理的语言之间建立了一个尴尬的接口，所以我们创建了第三种语言-模板-来避免它们。**这也有点尴尬。|4303771|现在让我们看一段引用的Lisp代码：|4303772|'(loop+for+i+from+1+to+8+do+(print+i))|4303773|你看到什么？作为一个新的Lisp程序员，我发现自己把它看作一个字符串。它不是。它是非活动的Lisp代码。你看到的是一堆列表和符号。在将其中一个圆括号转过来之后，尝试计算它。这种语言不会让你这么做:语法是强制的。|4303774|使用准引号，我们可以将自己的值硬塞到这个不活动的Lisp代码中：|4303775|`(loop+for+i+from+1+to+,whatever+do+(print+i))|4303776|注意鞋店的本质:一件东西已经被另一件东西取代了。我们没有将我们的值格式化为字符串。我们把它滑入代码中的一个位置。一切都很整洁。|4303777|事实上，如果你想直接编辑代码的文本，你就会遇到麻烦。例如，如果您要在代码中插入一个名称，并且还希望在相同的代码中使用-tmp，则不能像使用模板字符串那样直接执行此操作："%25s-tmp+=+%25s“。您必须将名称提取为字符串，重写字符串，然后再次将其转换为符号，最后插入。|4303778|如果你想掌握Lisp的本质，我认为如果你暂时忽略def宏和gensyms以及所有的装饰品，你可能会得到更多。花点时间探索准引号的潜力，包括，@这件事。这是非常容易理解的。Def宏本身只提供一种简单的方法来执行准引号的结果。***|4303779|您应该注意到的是，在Lisp中几乎消除了工作对象和工作对象之间的封闭字符串/模板屏障。当你使用它时，你会发现你对两个不同层次的感觉--主动和被动--趋于消散。函数调用宏调用宏或具有函数的函数(或宏！)与他们的参数一起传递。这是一种大汤-对新人来说有点令人震惊。也就是说，我认为宏和函数之间的区别并不像一些Lisp人员所说的那样无缝。大体上还可以，但当我在汤中徘徊时，我发现自己撞到了那个古老屏障的幽灵--它真的让我害怕！|4303780|我相信我会克服的。不管了。便利性为恐惧付出了代价。|4303781|这就是Lisp在Lisp上的工作。那么在其他语言上工作呢？就我个人而言，我还没有完全做到这一点，但我想我已经看到了隧道尽头的曙光。你知道Lisp的人一直在说S表达式和解析树是一回事吗？我认为我们的想法是将外语解析成S表达式，在令人惊叹的Lisp环境中处理它们，然后将它们发送回本机代码。从理论上讲，每种语言都可以转换成S表达式，甚至是可执行的lisp代码。你不是在用第一种语言和第三种语言相结合来产生第二种语言的代码。这就是所有的Lisp，你可以用准引号生成它。|4303782|看看这个(borrowed+from+PCL)：|offset|length|4303783|(define-html-macro+:mp3-browser-page+((&key+title+(header+title))+&body+body)
++`(:html
+++++(:head
++++++(:title+,title)
++++++(:link+:rel+"stylesheet"+:type+"text/css"+:href+"mp3-browser.css"))
+++++(:body
++++++(standard-header)
++++++(when+,header+(html+(:h1+:class+"title"+,header)))
++++++,@body
++++++(standard-footer))))|4303784|看起来像是HTML的S表达式版本，不是吗？我有一种感觉，Lisp作为自己的模板库工作得很好。|4303785|我开始想知道python的S-expression版本。它算得上是Lisp吗？它肯定不会是Common+Lisp。也许这样会更好--至少对python程序员来说是这样。嘿，那P-expressions呢？|4303786|*+Python现在有一个叫做AST的东西，我还没有研究过。此外，一个人还可以使用python列表来表示其他语言。相对于Lisp，我怀疑两者都有点像黑客。|4303787|**+SQLAlchemy是一种例外。它很好地将SQL直接转换成了python。尽管如此，它似乎涉及到了重大的努力。|4303788|*从新手那里学到。我确定我在掩饰一些东西。此外，我意识到准引号并不是生成宏代码的唯一方法。不过，这确实是一个很好的选择。|4303789|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gigamonkeys.com/book/practical-an-mp3-browser.html|1|http://archlinux.me/dusty/2012/10/16/python-on-android-first-impressions-of-kivy/^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|5|H|0|0|0|0|2F|D|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|2E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|2F|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|2G|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|2H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|2K|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2L|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2N|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2O|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|2P|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2R|8|@]|9|@]|A|$]]|$1|18|3|19|5|F|7|2S|8|@]|9|@]|A|$G|H]]|$1|1A|3|1B|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|2Z|8|@]|9|@$1O|30|1P|31|1|32]]|A|$]]|$1|1Q|3|1R|5|F|7|33|8|@]|9|@]|A|$G|H]]|$1|1S|3|1T|5|6|7|34|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|6|7|35|8|@]|9|@$1O|36|1P|37|1|38]]|A|$]]|$1|1W|3|1X|5|6|7|39|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|6|7|3A|8|@]|9|@]|A|$]]|$1|20|3|21|5|6|7|3B|8|@]|9|@]|A|$]]|$1|22|3|-4|5|6|7|3C|8|@]|9|@]|A|$]]]|23|$24|$5|25|26|27|A|$28|29]]|2A|$5|25|26|27|A|$28|2B]]]]

Okay, I'm going to take a crack at this. I'm new to Lisp myself, just having arrived from the world of python. I haven't experienced that sudden moment of enlightenment that all the old Lispers talk about, but I'll tell you what I am seeing so far.

First, look at this random bit of python code:

<pre><code>def is_palindrome(st):
 l = len(st)/2
 return True if st[:l] == st[:-l-1:-1] else False
</code></pre>

Now look at this: 

<pre><code>"""
def is_palindrome(st):
 l = len(st)/2
 return True if st[:l] == st[:-l-1:-1] else False
"""
</code></pre>

What do you, as a programmer, see? The code is identical, FYI. 

If you are like me, you'll tend to think of the first as active code. It consists of a number of syntactic elements.

The second, despite its similarity, is a single syntactic item. It's a string. You interact with it as a single entity. To deal with it as code - to handle it comfortably along its syntactic boundaries - you will have to do some parsing. To execute it, you need to invoke an interpreter. It's not the same thing at all as the first.

So when we do code generation in most languages what are we dealing with? Strings. When I generate HTML or SQL with python I use python strings as the interface between the two languages. Even if I generate python with python, strings are the tool.*

Doesn't the thought of that just... make you want to dance with joy? There's always this grotesque mismatch between that which you are working with and that which you are working on. I sensed that the first time that I generated SQL with perl. Differences in escaping. Differences in formatting: think about trying to get a generated html document to look tidy. Stuff isn't easy to reuse. Etc.

To solve the problem we serially create templating libraries. Scads of them. Why so many? My guess is that they're never quite satisfactory. By the time they start getting powerful enough they've turned into monstrosities. Granted, some of them - such as SQLAlchemy and Genshi in the python world - are very beautiful and admirable monstrosities. Let's... um... avoid mention of PHP. 

Because strings make an awkward interface between the worked-on language and the worked-with, we create a third language - templates - to avoid them. ** This also tends to be a little awkward.

Now let's look at a block of quoted Lisp code:

<pre><code>'(loop for i from 1 to 8 do (print i))
</code></pre>

What do you see? As a new Lisp coder, I've caught myself looking at that as a string. It isn't. It is inactive Lisp code. You are looking at a bunch of lists and symbols. Try to evaluate it after turning one of the parentheses around. The language won't let you do it: syntax is enforced.

Using quasiquote, we can shoehorn our own values into this inactive Lisp code:

<pre><code>`(loop for i from 1 to ,whatever do (print i))
</code></pre>

Note the nature of the shoehorning: one item has been replaced with another. We aren't formatting our value into a string. We're sliding it into a slot in the code. It's all neat and tidy.

In fact if you want to directly edit the text of the code, you are in for a hassle. For example if you are inserting a name &lt;varname&gt; into the code, and you also want to use &lt;varname&gt;-tmp in the same code you can't do it directly like you can with a template string: "%s-tmp = %s". You have to extract the name into a string, rewrite the string, then turn it into a symbol again and finally insert.

If you want to grasp the essence of Lisp, I think that you might gain more by ignoring defmacro and gensyms and all that window dressing for the moment. Spend some time exploring the potential of the quasiquote, including the ,@ thing. It's pretty accessible. Defmacro itself only provides an easy way to execute the result of quasiquotes. ***

What you should notice is that the hermetic string/template barrier between the worked-on and the worked-with is all but eliminated in Lisp. As you use it, you'll find that your sense of two distinct layers - active and passive - tends to dissipate. Functions call macros which call macros or functions which have functions (or macros!) passed in with their arguments. It's kind of a big soup - a little shocking for the newcomer. That said, I don't find that the distinction between macros and functions is as seamless as some Lisp people say. Mostly it's ok, but every so often as I wander in the soup I find myself bumping up against the ghost of that old barrier - and it really creeps me out!

I'll get over it, I'm sure. No matter. The convenience pays for the scare.

Now that's Lisp working on Lisp. What about working on other languages? I'm not quite there yet, personally, but I think I see the light at the end of the tunnel. You know how Lisp people keep going on about S-expressions being the same thing as a parse tree? I think the idea is to parse the foreign language into S-expressions, work on them in the amazing comfort of the Lisp environment, then send them back to native code. In theory, every language out there could be turned into S-expressions, or even executable lisp code. You're not working in a first language combined with a third language to produce code in a second language. It is all - while you are working on it - Lisp, and you can generate it all with quasiquotes.

Have a look at this (<a href="http://www.gigamonkeys.com/book/practical-an-mp3-browser.html" rel="nofollow">borrowed from PCL</a>):

<pre><code>(define-html-macro :mp3-browser-page ((&amp;key title (header title)) &amp;body body)
 `(:html
 (:head
 (:title ,title)
 (:link :rel "stylesheet" :type "text/css" :href "mp3-browser.css"))
 (:body
 (standard-header)
 (when ,header (html (:h1 :class "title" ,header)))
 ,@body
 (standard-footer))))
</code></pre>

Looks like an S-expression version of HTML, doesn't it? I have a feeling that Lisp works just fine as its own templating library.

I've started to wonder about an S-expression version of python. Would it qualify as a Lisp? It certainly wouldn't be Common Lisp. Maybe it would be nicer - for python programmers at least. Hey, and what about <a href="http://archlinux.me/dusty/2012/10/16/python-on-android-first-impressions-of-kivy/" rel="nofollow">P-expressions</a>?

* Python now has something called AST, which I haven't explored. Also a person could use python lists to represent other languages. Relative to Lisp, I suspect that both are a bit of a hack.

** SQLAlchemy is kind of an exception. It's done a nice job of turning SQL directly into python. That said, it appears to have involved significant effort.

*** Take it from a newbie. I'm sure I'm glossing over something here. Also, I realize that quasiquote is not the only way to generate code for macros. It's certainly a nice one, though.

I've read <a href="http://www.defmacro.org/ramblings/lisp.html" rel="noreferrer">The Nature of Lisp</a>. The only thing I really got out of that was "code is data." But without defining what these terms mean and why they are usually thought to be separate, I gain no insight. My initial reaction to "code is data" is, so what?

How do I 'get' Lisp?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我读过。我唯一真正从中学到的就是“代码就是数据”。但在没有定义这些术语的含义以及为什么它们通常被认为是独立的情况下，我得不到任何见解。我对“代码就是数据”的最初反应是，那又如何？

问如何“获得”Lisp？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何“获得”Lisp？EN