4 ms·

The JVM indeed quickly got me disinterested in Clojure. However, I have similar issues with other (free) Lisps, with probably only Emacs Lisp being the exceptio

The JVM indeed quickly got me disinterested in Clojure. However, I have similar issues with other (free) Lisps, with probably only Emacs Lisp being the exception. As a Smalltalker ("the other heroin of the programming world") I'm used to a highly integrated and responsive development environment; from what I heard from other Lispers, the quick feedback and gradual building up of your program is a shared aspect, but the thing that Smalltalkers always bring up and Lispers less so is also that your program and your IDE are basically indistinguishable, which is quite powerful because it makes it trivial to adapt your IDE to your project as you go. In the Lisp environments I've tried - latest being Emacs+SBLC - the split between editor and REPL seems unnatural to me, more so because in the standard case you work with two different dialects of the language. It seems that only ACL and LW have more unification. Am I wrong and are the $$$$ versions not better in that respect and should I just drop my Smalltalk habits/arguments when learning CL?

lispm 10y ago
> also that your program and your IDE are basically indistinguishable Lisp provides that,too. But you can also deliver programs with the IDE and much of the development tools removed. Examples for integrated IDEs: Allegro CL on Windows/Unix+Gtk, Clozure CL (free) on Macs, LispWorks on Windows/Macs/Unix+GTK/Unix+Motif. There the IDE and the user code runs in one Lisp. Other examples: Lisp Machines, CMUCL on X11, ... there is also the McCLIM project where some ideas from the Symbolics GUI are used. There are also countless other implementations from the past, which are now mostly forgotten, which had an integrated IDE (Golden Common Lisp for Windows, Corman Lisp for Windows, Macintosh Common Lisp, Medley, Open Genera for X11...),
- iheartmemcache 10y ago
  You should really write an analysis contrasting the functionality of these IDEs, especially those 'mostly forgotten' ones so they aren't lost into the abyss. I've used Squeak Smalltalk and DrRacket in the past. As someone who finds slime/swank/sbcl in Emacs a pleasure, I can only imagine how great some of those other environments can be.
- vram22 10y ago
  Hi, I read this article on your site: http://lispm.de/why-lisp-is-different http://lispm.de/why-lisp-is-different Quote from it: [ When in doubt design software to be introspective. when in doubt design software to be reflective. ] What is the difference between introspective and reflective? I've used introspection in Python and know about and used (a bit) reflection in Java earlier, but thought they were roughly the same sort of thing. Please explain the difference if possible.
  - lispm 10y ago
    Introspection means that the program's structures and procedures are discoverable and we can query about them. Typical questions we might want to have answers for: * find me the class, typically by name or by some relationship * what are the fields of that class? * find me a function * what are the arguments of the function? does it have documentation? Who wrote it? Where is its source? What values does it return? * where is the function used? what functions does it call? * what are the values of a field of some object? What class does it have? This and more for example enables you to inspect a program at runtime and find out what it does, how it does it and what its state currently is. Reflection means that elements of the programming language are itself exposed and we can change/extend them. Two examples of the Lisp world. Very unusual is the reflective tower, where a Lisp program is run by some kind of machine, which for example is a Lisp interpreter. This Lisp interpreter is itself a Lisp program. Thus you can not only write the program, but you can change/extend the interpreter running the program. A certain Lisp dialect allowed also to look at the interpreter running the interpreter running the interpreter running the interpreter ... In Common Lisp a typical form of reflection is the Meta-Object Protocol of CLOS. It allows you to program the object system to implement new variants: persistent objects, transactions over objects, different inheritance mechanisms, classes which record their instances, ... Thus the MOP exposes classes, methods, generic functions, slot descriptors, ... as CLOS classes and methods - and protocols about them. Thus CLOS can be programmed in itself. Even at runtime. More primitive reflection would allow you to create/change/remove things like user classes and user methods. Task: create a new subclass of an existing class at runtime.
    - vram22 10y ago
db48x 10y ago
You might find MIT Scheme interesting, because it has a built-in Emacs clone. Just call (edit) and you're in. I think what it really comes down to is that writing and maintaining an editor (especially a good one) is a very large task. A language that lets you use an editor you already like thus has a double advantage, with the possible downside that the integration won't be as good as possible. SLIME is pretty nice though.

lispm 10y ago

> also that your program and your IDE are basically indistinguishable Lisp provides that,too. But you can also deliver programs with the IDE and much of the development tools removed. Examples for integrated IDEs: Allegro CL on Windows/Unix+Gtk, Clozure CL (free) on Macs, LispWorks on Windows/Macs/Unix+GTK/Unix+Motif. There the IDE and the user code runs in one Lisp. Other examples: Lisp Machines, CMUCL on X11, ... there is also the McCLIM project where some ideas from the Symbolics GUI are used. There are also countless other implementations from the past, which are now mostly forgotten, which had an integrated IDE (Golden Common Lisp for Windows, Corman Lisp for Windows, Macintosh Common Lisp, Medley, Open Genera for X11...),

iheartmemcache 10y ago
You should really write an analysis contrasting the functionality of these IDEs, especially those 'mostly forgotten' ones so they aren't lost into the abyss. I've used Squeak Smalltalk and DrRacket in the past. As someone who finds slime/swank/sbcl in Emacs a pleasure, I can only imagine how great some of those other environments can be.
vram22 10y ago
Hi, I read this article on your site: http://lispm.de/why-lisp-is-different http://lispm.de/why-lisp-is-different Quote from it: [ When in doubt design software to be introspective. when in doubt design software to be reflective. ] What is the difference between introspective and reflective? I've used introspection in Python and know about and used (a bit) reflection in Java earlier, but thought they were roughly the same sort of thing. Please explain the difference if possible.
- lispm 10y ago
  Introspection means that the program's structures and procedures are discoverable and we can query about them. Typical questions we might want to have answers for: * find me the class, typically by name or by some relationship * what are the fields of that class? * find me a function * what are the arguments of the function? does it have documentation? Who wrote it? Where is its source? What values does it return? * where is the function used? what functions does it call? * what are the values of a field of some object? What class does it have? This and more for example enables you to inspect a program at runtime and find out what it does, how it does it and what its state currently is. Reflection means that elements of the programming language are itself exposed and we can change/extend them. Two examples of the Lisp world. Very unusual is the reflective tower, where a Lisp program is run by some kind of machine, which for example is a Lisp interpreter. This Lisp interpreter is itself a Lisp program. Thus you can not only write the program, but you can change/extend the interpreter running the program. A certain Lisp dialect allowed also to look at the interpreter running the interpreter running the interpreter running the interpreter ... In Common Lisp a typical form of reflection is the Meta-Object Protocol of CLOS. It allows you to program the object system to implement new variants: persistent objects, transactions over objects, different inheritance mechanisms, classes which record their instances, ... Thus the MOP exposes classes, methods, generic functions, slot descriptors, ... as CLOS classes and methods - and protocols about them. Thus CLOS can be programmed in itself. Even at runtime. More primitive reflection would allow you to create/change/remove things like user classes and user methods. Task: create a new subclass of an existing class at runtime.
  - vram22 10y ago

db48x 10y ago

You might find MIT Scheme interesting, because it has a built-in Emacs clone. Just call (edit) and you're in. I think what it really comes down to is that writing and maintaining an editor (especially a good one) is a very large task. A language that lets you use an editor you already like thus has a double advantage, with the possible downside that the integration won't be as good as possible. SLIME is pretty nice though.