i’m wondering what 9fans think about lisp, specifically scheme.
Cat-v.org has given a nod to Scheme.
Chibi-Scheme has run on Plan 9.
A useful Scheme interpreter can be written in about 10k lines of clear C
code.
they’re both the powerful synthesis of simple ideas. i don’t see any
mention of it as it compares to 9, but they don’t seem incompatible.
personally i think they compliment each other in nice ways.
Plan 9 uses files as the organizing metaphor. Lisp uses objects.
(Lispers don't care too much about organizing objects into class
hierarchies; we care about them in the Smalltalk sense, "something you
can call to do a job". Every function is an object in Lisp.)
https://github.com/mntmn/interim is a hobby OS that tries to combine the
two. I haven't looked at it in detail but the idea may be "too much of a
good thing": the two metaphors cover some of the same ground, so there
is redundancy between them. The Lisp instinct is to represent system
services as objects, not files.
i don’t have any interest in emacs, i don’t even know what it is. nor
clojure or any of that.
Emacs = A very imperfect Lisp machine emulator written in C. The code
written for Emacs mostly deals with text editing, but the Lisp system is
actually broad enough for general-purpose programming.
Clojure = Java. That may be all 9fans want to know :-)
i’m talking about lisp being able to manipulate the structure of the
program with tools that are built into the language.
Lisp tends to focus on macros and other S-expression transformations,
i.e. metaprogramming at as a batch job (at compile time, etc.)
Smalltalk focuses on reflection, i.e. metaprogramming at run time.
Same idea, but Smalltalk is much more dynamic. Most Lisp systems can do
a lot of runtime reflection but it's not customary to reach for it as
the first tool of choice. This is more of a cultural matter than a
technical issue, though culture determines which aspects of the
implementations are the most polished and comprehensive.
Scheme tends to be less dynamic than Lisp generally. This is also a
matter of culture, not an intrinsic technical issue. Schemers constantly
talk about efficiency.
Almost all Lisp dialects use dynamic typing. Almost all Lisp
implementations (of any dialect) support interactive development, and
this is the normal way to write Lisp.
Other languages known for metaprogramming: Forth, Rebol.
------------------------------------------
9fans: 9fans
Permalink:
https://9fans.topicbox.com/groups/9fans/T7b0afbefb53189b6-M686c85cafb595890bbb47f8d
Delivery options: https://9fans.topicbox.com/groups/9fans/subscription
