lisp

I don't understand how Lisp can be compiled and dynamic. For a language to be able to manipulate and modify and generate code, isn't it a requirement to be interpreted? Is it possible for a language to be completely compiled and still be dynamic? Or am I missing something? What is Lisp doing that allows it to be both compiled and dynamic? Lisp is a wide family of language and implementations. Dynamic in the context of Lisp means that the code has a certain flexibility at runtime. It can be changed or replaced for example. This is not the same as dynamically typed . Compilation in Lisp Often

In Lisp, any program's code is actually a valid data structure. For example, this adds one and two together, but it's also a list of three items. (+ 1 2) What benefit does that provide? What does that enable you to do that's impossible and/or less elegant in other languages? To make things a little clearer with respect to code representation, consider that in every language code is data: all you need is strings. (And perhaps a few file operations.) Contemplating how that helps you to mimic the Lisp benefits of having a macro system is a good way for enlightenment. Even better if you try to

I'm learning Clojure and I'm trying to define a function that take a variable number of parameters (a variadic function) and sum them up (yep, just like the + procedure). However, I don´t know how to implement such function Everything I can do is: (defn sum [n1, n2] (+ n1 n2)) Of course this function takes two parameteres and two parameters only. Please teach me how to make it accept (and process) an undefined number of parameters. In general, non-commutative case you can use apply : (defn sum [& args] (apply + args)) Since addition is commutative, something like this should work too: (defn

So Mathematica is different from other dialects of lisp because it blurs the lines between functions and macros. In Mathematica if a user wanted to write a mathematical function they would likely use pattern matching like f[x_]:= x*x instead of f=Function[{x},x*x] though both would return the same result when called with f[x] . My understanding is that the first approach is something equivalent to a lisp macro and in my experience is favored because of the more concise syntax. So I have two questions, is there a performance difference between executing functions versus the pattern matching

Are there any good, cross platform (SBCL and CLISP at the very least) easy to install GUI libraries? Ltk is quite popular, very portable, and reasonably well documented through the Tk docs. Installation on SBCL is as easy as saying: (require :asdf-install) (asdf-install:install :ltk) There's also Cells-Gtk , which is reported to be quite usable but may have a slightly steeper learning curve because of its reliance on Cells. EDIT: Note that ASDF-INSTALL is integrated this well with SBCL only . Installing libraries from within other Lisp implementations may prove harder. (Personally, I always

I'm working through SICP. Currently, in the first chapter, I'm having problems getting Racket to let me redefine "primitives". For instance, I was under the impression that I should be able to arbitrarily do (define + 5) and that would be fine, or redefine the sqrt procedure. Instead, I get this: define-values: cannot change constant variable: + I have the language currently set to R5RS, which I was under the impression would take care of the compatibility issues with SICP. Eli Barzilay Even if possible, such redefinitions are not something that you should do without really understanding how