21–30 of 110 posts
Earlier quoted context omitted.
Haskell also supports metaprogramming and a REPL, these are not unique to Lisp. But granted, Lisp's syntax makes metaprogramming very convenient.
AFAIK Haskell doesn't support metaprogramming. Perhaps you mean "Template Haskell"?
On the other hand, the spirit of Lisp has successfully taken over the world. The modern Lisp is called JavaScript.
I am perfectly aware of all the differences between Lisp and JavaScript and of the other languages that have influenced JavaScript (Self, Perl, Lua), but think of this: what made Lisp so great in the past?
- automatic memory management (compared to Fortran/C);
- very dynamic language and environment,
hooks on everything, live systems;
`eval`, available meta-interpreter;
- exceptions and condition system instead of segfaults;
- multi-paradigm, flexible programming language:
functional, OO and imperative programming when needed;
- research roots and great minds behind the language;
JavaScript has fixed S-expressions; "I can program in S-expressions" does not mean "I should". Macros are harmful to programming in the large.
JavaScript applied existing lessons about data structures and object systems to the language: "I can roll out my own object system" does not mean "I should" and creates a Babel tower of incompatible object systems instead of a common language. JavaScript got rid of linked lists (that are awkward and impractical for everyday use) and introduced hash-tables into the language.
The modern JS ecosystem seems to be exactly what a Common Lisp ecosystem would have been if it had existed in the first place: the same diversity, the same problems, the same churn rate (because the language is powerful and writing new stuff is easy).
JavaScript has also successfully escaped perception of "a language for brains". Research background is actually harmful for a modern programming language. Examples are abound: Haskell is widely derided by the industry, slightly researchy Scala is "borderline unmanageable" for many and teams move back to Java; C++ with its experiments is tolerated for its interoperability with C, but gets a lot of (deserved) hate for its (often unnecessary) complication (hopefully, Rust has a good cover for the industry as "enhanced C++"); simplistic Go takes the world over by storm; the web is mostly written in PHP, whose inventors are as far from PL research as one can get.
Earlier quoted context omitted.
Haskell appeared in 1990. Around 1987 I was as a student sitting in front of a real Lisp Machine, a Symbolics 3600, running in an AI research lab for natural language interaction. The machine with a stack-based CPU ran an object-oriented operating system written in a million lines of Lisp, with full source code and runtime changes. There is nothing which will blow your mind like that.
Those amazing Lisp machines were far ahead of their time. Unfortunately the hardware was very expensive, and it lacked power. Today we have the right cheap hardware. Actually, there is a Lisp revival going on in the OSS community. Consider McClim [1] for instance which attempts to port the amazing GUI of the Lisp Machines to PCs. It already works. [1] https://common-lisp.net/project/mcclim/
Earlier quoted context omitted.
I can't answer for GP, but to me personally, I had prior experience in both Haskell and Erlang before jumping into Clojure. And I can say that I share the feeling: Lisp changed the way I approach programming. Probably metaprogramming (the all-mighty macros & co.) and REPL-driven development are the two most important things I learned from Clojure (and Lisp in general). And I won't say that the paradigm shift to funct…
Haskell also supports metaprogramming and a REPL, these are not unique to Lisp. But granted, Lisp's syntax makes metaprogramming very convenient.
When doing theorem proving in Ocaml (which was both ML's and Lisp's MOs), my REPL session could last months. I sadly didn't have Lisp's great (save-lisp-and-die) in Ocaml, but I was able to snapshot the process state to get semiway there.
Common Lisp is built around the idea that your runtime is a persistent live system that you stay in and modify and introspect. Your tool-chain should consist entirely of Lisp objects that are part of your runtime, and should themselves be modifiable. Everything is programmable. The Art of the Metaobject Protocol is still one of the coolest things I've ever read.
I'm a Haskeller now, through and through, but Haskell's REPL and runtime isn't comparable to Lisp's.
Earlier quoted context omitted.
Haskell appeared in 1990. Around 1987 I was as a student sitting in front of a real Lisp Machine, a Symbolics 3600, running in an AI research lab for natural language interaction. The machine with a stack-based CPU ran an object-oriented operating system written in a million lines of Lisp, with full source code and runtime changes. There is nothing which will blow your mind like that.
Those amazing Lisp machines were far ahead of their time. Unfortunately the hardware was very expensive, and it lacked power. Today we have the right cheap hardware. Actually, there is a Lisp revival going on in the OSS community. Consider McClim [1] for instance which attempts to port the amazing GUI of the Lisp Machines to PCs. It already works. [1] https://common-lisp.net/project/mcclim/
Fanatics deliberately abandon objective judgement. Many of the quotes makes me question the authors experience. Everything is relative. Compared to Fortran, Lisp is all that and more. Compared to modern languages (say, Haskell), not so much.
> Many of the quotes makes me question the authors experience Do you have enough experience that you dare to judge him? > Compared to modern languages (say, Haskell), not so much. I disagree. I was in a lot of languages, in all different programming styles. Lisp still is the language with a maximum of freedom of programming, probably also regarding productivity. Only Nim comes close. Haskell may look elegant at the s…
- and takes negligible maintenance/refactoring time compared to Lisp/Python/C++. Maintenance timesink might easily outweigh the gain in development time.
That's the promise of strong type systems: preventing bugs from happening before you have to debug them in production and it does not come absolutely free.
Lisp is a beautiful language (or, to be more precise, set of languages). It is absolutely essential to a computer science education. It also gets unwieldy when programs get complex.
Lisp is the best language for any task that does not require types.
Earlier quoted context omitted.
Haskell appeared in 1990. Around 1987 I was as a student sitting in front of a real Lisp Machine, a Symbolics 3600, running in an AI research lab for natural language interaction. The machine with a stack-based CPU ran an object-oriented operating system written in a million lines of Lisp, with full source code and runtime changes. There is nothing which will blow your mind like that.
Those amazing Lisp machines were far ahead of their time. Unfortunately the hardware was very expensive, and it lacked power. Today we have the right cheap hardware. Actually, there is a Lisp revival going on in the OSS community. Consider McClim [1] for instance which attempts to port the amazing GUI of the Lisp Machines to PCs. It already works. [1] https://common-lisp.net/project/mcclim/
