Update
This commit is contained in:
parent
21973f4724
commit
a8a9ce5cfc
22 changed files with 2026 additions and 1983 deletions
2
lisp.md
2
lisp.md
|
@ -14,7 +14,7 @@ Lisps also have various systems of [macros](macro.md) that allow to extend the l
|
|||
|
||||
**Lisp is high level but [minimalist](minimalism.md)**, a rare beast to witness, an unusual combination to see at least [nowadays](21st_century.md), but not a bad combination -- high level languages are not necessarily evil, it's just that [bloat](bloat.md) is evil and high level usually implies bloat. However Lisp manages to stay nice -- the language is defined in very abstract ways, treating values in memory as abstract entities rather than sequences of [bits](bit.md), not bothering the programmer with memory management etc. -- this is subsequently usually [optimized](optimization.md) under the hood by compilers/interpreters to a more machine friendly code, however the programmer doesn't have to care, it's enough he knows the abstract behavior. Of course there are penalties for this, ignoring what's going on behind the curtains always comes for a price, but Lisp makes this choice willingly and implements it so as to gain the advantages of high level while minimizing the penalties -- for example the language is designed so that it can be implemented in a minimalist way. So basically we could call Lisp a *high level language done right*.
|
||||
|
||||
**How do the Lisp dialects differ?** Potentially in many different ways: some focus on pragmatism, some on minimalism, some add their own extensions and features, some modify the language itself while some just provide extra libraries, some just put more emphasis on different things (e.g. PicoLisp is more datacentric), some try to support more paradigms such as [OOP](oop.md), some just try to do things differently than others. For example let's examine Common Lisp versus Scheme: Common Lisp is more "bloated", has a big standard library, Scheme is more minimalist, enforces tail recursion to be optimized (and so more encourages functional programming) and mostly doesn't specify order of argument evaluation, Common Lisp evaluates arguments from left to right and supports dynamic scope while Scheme only supports lexical scope, and so on and so [forth](forth.md). From someone coming from the world of C -- where C is simply C -- this world may invoke a cultural shock and information overload: there are different Lisp dialects, each with different standards, each with different implementation. But ultimately there is richness, evolution and a great deal of choice in it. Some of the most notable List dialects include:
|
||||
**How do the Lisp dialects differ?** Potentially in many different ways: some focus on pragmatism, some on minimalism, some add their own extensions and features, some modify the language itself while some just provide extra libraries, some just put more emphasis on different things (e.g. PicoLisp is more datacentric), some try to support more paradigms such as [OOP](oop.md), some just try to do things differently than others. For example let's examine Common Lisp versus Scheme: Common Lisp is more "bloated", has a big standard library, Scheme is more minimalist, enforces tail recursion to be optimized (and so more encourages functional programming) and mostly doesn't specify order of argument evaluation, Common Lisp evaluates arguments from left to right and supports dynamic scope while Scheme only supports lexical scope, and so on and so [forth](forth.md). From someone coming from the world of C -- where C is simply C -- this world may invoke a cultural shock and information overload: there are different Lisp dialects, each with different standards, each with different implementation. But ultimately there is richness, evolution and a great deal of choice in it. Among some of the most noteworthy Lisp dialects are:
|
||||
|
||||
- **Common Lisp** (CL): The "big", [bloated](bloat.md) (for Lisp standards), "feature rich" kind of Lisp, around since 1984; it is widely supported and well standardized by ANSI.
|
||||
- **Scheme** (and descendants such as *Racket*): Well established minimalist branch of Lisp, around since 1975.
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue