More, essentially all research in self-reference for decades has been in artificial intelligence, which is the device around which this plot turns. The language of AI is LISP, the name of the archvillain. In the heyday of LISP machines, the leading system was Flavors LISP Object Oriented Programming or: you guessed it -- Floop. I myself worked on a defense AI program that included the notion of a `third brain,' that is an observer living in a world different than (1) that of the world's creator, and (2) of the characters.

kons-9 is that it combines the power of a software development IDE with the visual tools of 3D graphics authoring system. It does this by being implemented in Common Lisp, an object-oriented dynamic language which provides powerful facilities for exploratory development and rapid prototyping within a live interactive software environment

An OS as an interactive image that runs independent services that communicate via message-passing.

We already did, it was called Lisp Machines and Smalltalk, and we are yet to fully replicate them.

怎样支持递归定义/初始化变量（相较于几乎所有现代语言都支持函数定义递归）？

Scheme 适合用来做什么？

如何写 Lisp 解释器？

Racket有contract为什么还要加一个type system？

为什么大部分编程语言不支持宏？

对r6rs中一个letrec实现的问题?

什么语言最适合写编译器/解释器？

LISP可以做什么？

Common Lisp 为什么不用卫生宏？

如何评价 The Little Schemer 系列的文风？

精通 Lisp 是一种怎样的体验？

为什么lisp开始是为了人工智能创造的，可是现在人工智能火了，lisp却被冷落了？

Lisp machine 这种用 Lisp 代码当机器的汇编指令的硬件实现为什么销声匿迹了？硬件和 Lisp 这样的高级语言两个极端如何融合在一起？

Lisp的精髓是什么？

scheme中的continuation实现原理是什么？

如何用七条公理构造call/cc？

Typed Racket相对于Racket会有多少性能提升？

为什么说racket中的syntax object是卫生宏的基础础？

Racket这种可以把语言特性写成库的语言为何没有得到广泛的工业应用？

Lisp 中的 string 和 symbol 的区别？

Call by name 的语言能模拟 call by value 吗？

如何评价 Racket 这门编程语言？

Chez scheme是怎样一个编译器啊，听说编译后的scheme代码速度能媲美C？有人用过么？

从Chez Scheme源码可以看到的高明之处有哪些？

如何解释 Lisp 中 call/cc 的概念？

Experienced Lisp programmers divide up their programs differently. As well as top-down design, they follow a principle which could be called bottom-up design-- changing the language to suit the problem. In Lisp, you don't just write your program down toward the language, you also build the language up toward your program. As you're writing a program you may think "I wish Lisp had such-and-such an operator." So you go and write it. Afterward you realize that using the new operator would simplify the design of another part of the program, and so on. Language and program evolve together. Like the border between two warring states, the boundary between language and program is drawn and redrawn, until eventually it comes to rest along the mountains and rivers, the natural frontiers of your problem. In the end your program will look as if the language had been designed for it. And when language and program fit one another well, you end up with code which is clear, small, and efficient.

this kind of run-time code generation is certainly more natural in Ruby, it's one of its Lispish elements

Note that variables cannot appear in the predicate position.

When you're writing software that is only going to run on your own servers, you can use whatever language you want.

The first indication of a change in weather was the sudden collapse of the market for specialized AI hardware in 1987. Desktop computers from Apple and IBM had been steadily gaining speed and power and in 1987 they became more powerful than the more expensive Lisp machines made by Symbolics and others. There was no longer a good reason to buy them. An entire industry worth half a billion dollars was demolished overnight.

The Lisp Machine (which could just as easily have been, say, a Smalltalk machine) was a computing environment with a coherent, logical design, where the “turtles go all the way down.” An environment which enabled stopping, examining the state of, editing, and resuming a running program, including the kernel. An environment which could actually be fully understood by an experienced developer.  One where nearly all source code was not only available but usefully so, at all times, in real time.  An environment to which we owe so many of the innovations we take for granted. It is easy for us now to say that such power could not have existed, or is unnecessary. Yet our favorite digital toys (and who knows what other artifacts of civilization) only exist because it was once possible to buy a computer designed specifically for exploring complex ideas.  Certainly no such beast exists today – but that is not what saddens me most.  Rather, it is the fact that so few are aware that anything has been lost.

Although regular macros work on programs in the form of trees, a special type of macro, called a read macro, operates on the raw characters that make up your program.

Perhaps part of the confusion - and you say this in a different way in your little memo - is that the C/C++ folks see OO as a liberation from a world that has nothing resembling a first-class functions, while Lisp folks see OO as a prison since it limits their use of functions/objects to the style of (9.). In that case, the only way OO can be defended is in the same manner as any other game or discipline -- by arguing that by giving something up (e.g. the freedom to throw eggs at your neighbor's house) you gain something that you want (assurance that your neighbor won't put you in jail).

Ad hoc polymorphism - functions and data structures with parameters that can take on values of many different types.

Encapsulation - the ability to syntactically hide the implementation of a type. E.g. in C or Pascal you always know whether something is a struct or an array, but in CLU and Java you can hide the difference.

Lisp macros were also useful for the definition of new control structures, as well as new data structures. In ZWEI, we created a new iterative control structure called charmap, which iterates over characters in an interval. Intervals are stored as doubly-linked lists of arrays, and the starting point might be in the middle of one array and the ending point might be in the middle of another array. The code to perform this iteration was not trivial, and someone reading it might easily not understand the function it was performing, even though that function was the conceptually simple one of iterating over characters. So we created a macro called charmap that expands into the double-loop code to iterate over the characters. It is simple and obvious, and is used in many places, greatly reducing the size of the code and making the functionality obvious at a glance.

It became policy to avoid abbreviations in most cases. In ZWEI, we made a list of several words that were used extremely often, and established 'official' abbreviations for them, and always used only those abbreviations. ... Words not on this list were always spelled out in full.

The use of the mouse is still considered experimental. We know of several editors which depend highly on the use of a mouse for input, but we are not convinced that it is better than a keyboard; after more people start using ZWEI, it will be interesting to see how many of them make heavy use of the mouse and how many hardly use it at all.

Since ZWEI is written in Lisp and lives in the Lisp environment of the Lisp machine, it is in a very good position to interface closely with other elements of that environment.

ZWEI is display-oriented: the text the user is editing is actually displayed (this is relevant because many editors of the time often showed out-of-date text due to efficiency and bandwidth restrictions, putting the burden on the user to imagine what their text looks like currently).

Some paragraphs are devoted to what must have been a novel concept at the time for such a system: that the Lisp Machine was a personal system, not time-shared, and this gave rise to features not viable on time-sharing systems, due to the fact that the user was not contending with other users for resources.

Clojure at a Real Estate Portal

Lisp Quickstart