
Lispers - tosh
http://lispers.org
======
hellofunk
It sounds like hypberbole, but the quotes are true. I was professionally
writing Objective-C, C++ and eventually Swift for many years before using
Clojure full-time for a year. My Objective-C, Swift and C++ don't look the
same any more. It does change how you think about programming, in any
language. And makes you better across the board.

~~~
willtim
But was it Clojure or perhaps functional programming in general that "changed
how you think about programming"?

~~~
setzer22
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 functional programming didn't
broaden my view either, my point is that there is more to Lisp than being
functional-ish.

~~~
willtim
Haskell also supports metaprogramming and a REPL, these are not unique to
Lisp. But granted, Lisp's syntax makes metaprogramming very convenient.

~~~
ninesigns
AFAIK Haskell doesn't support metaprogramming. Perhaps you mean "Template
Haskell"?

~~~
willtim
Template Haskell _is_ meta-programming. It supports quasi-quotation, just like
Lisp.

~~~
lispm
quasi-quotation is an unrelated feature in Lisp. It's there to build list
structures from templates. Using templates in macros is sometimes helpful,
sometimes not.

~~~
willtim
In Template Haskell quasi-quotation is how one would add new syntax, but it's
not necessary either if all that is required is macro expansion.

------
Fej
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.

~~~
sds2
No, it shouldn't be. Lisp is not practical(try to prove it otherwise, there's
no evidence) and it's only a thing now because some ppl likes its esoteric
syntax. It's way too overhyped.

~~~
Risord
Real apps has been built with lisp so therefore it's at least some what
practical. On the other hand I just cannot see anything fundamental which
makes lisp lot less practical from many commonly used business languages. Well
ecosystem size may not same but on day one most languages haven't Hugo
ecosystem.

There are lot of schools and if you are "be a cool web app developer"-school
where you learning direct skills reauired most common web dev jobs today...
Yeah lisp is not essential. But if you are "computer SCIENCE"-school and you
targeting variety of fundamental cocepts of field I say that lisp is quite
essential.

~~~
sds2
> But if you are "computer SCIENCE"-school and you targeting variety of
> fundamental cocepts of field I say that lisp is quite essential.

I'm sure you've nothing to do with compsci because lisp is a useless language
family. If anything is recommended than it's rust, c and idris.

~~~
shakna
> I'm sure you've nothing to do with compsci because lisp is a useless
> language family. If anything is recommended than it's rust, c and idris.

Scheme is particularly suited to parsing, interpreting and compiling.[0][1]
There's a reason GCC's internals often look like Lisp.

If you exclude language design from computer science, then maybe Lisp becomes
a "useless language family", but there's a reason MIT Scheme was created.

[0] [https://mitpress.mit.edu/sicp/](https://mitpress.mit.edu/sicp/)

[1]
[https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces](https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces)

~~~
sds2
You can do that more efficiently with any ML language.

> There's a reason GCC's internals often look like Lisp.

Dude, that notation is not original to lisp...

~~~
shakna
> You can do that more efficiently with any ML language.

So first you say Lisp is useless in compsci because of the existence of "rust,
c and idris", and now its pointless to use it because of ML?

> Dude, that notation is not original to lisp...

Firstly: Have you actually looked at an MD file? [0] RTL is a Lisp dialect.

Secondly: The first paper on S-Expressions appeared in November, 1997.
McCarthy's first paper on what would become Lisp in 1982. I'm aware of no
language, and can find reference to no language, that used that notation
before Lisp did, so yes it is original to Lisp.

[0]
[https://gcc.gnu.org/git/?p=gcc.git;a=blob_plain;f=gcc/config...](https://gcc.gnu.org/git/?p=gcc.git;a=blob_plain;f=gcc/config/aarch64/aarch64.md;hb=172881b016150e383411bfbbe8bf757bff62f22b)

~~~
sds2
> So first you say Lisp is useless in compsci because of the existence of
> "rust, c and idris", and now its pointless to use it because of ML?

Idris and Rust are ML descendants and C helps you to learn the basics of low-
level programming. Lisp on the other hand won't teach you anything. How hard
is this to understand?

> Secondly: The first paper on S-Expressions appeared in November, 1997.

That was just a draft of an RFC which never got approved. S-Expressions are
MUCH older - it's "Polish Notation" invented by Jan Łukasiewicz in 1924

> McCarthy's first paper on what would become Lisp in 1982.

Lisp was specified in 1958.

> I'm aware of no language, and can find reference to no language, that used
> that notation before Lisp did, so yes it is original to Lisp.

1\. It's not about who used that notation but who invented it - not McCarthy;
2. that notation is practically useless for programming languages but they're
good for ASTs.

~~~
shakna
> Lisp on the other hand won't teach you anything. How hard is this to
> understand?

Difficult when _the definitive_ compsci course, Structure and Interpretation
of Computer Programs starts, and ends, with Lisp.

> S-Expressions are MUCH older - it's "Polish Notation" invented by Jan
> Łukasiewicz in 1924

No. Polish notation, as described by Łukasiewicz, is:

> I came upon the idea of a parenthesis-free notation in 1924

Polish notation has a strict set of precedence rules, and no parentheses. At
all.

S-Expressions _contain_ Polish notation, but is a superset that allows you to
specify arguments in a less painful precedence than Polish notation, and with
variadic arguments, which is not possible in Polish notation.

> that notation is practically useless for programming languages but they're
> good for ASTs.

Several decades of computer science disagree with you.

------
olewhalehunter
What are some examples of open source Lisp projects and codebases whose
features and elegance could have only been executed as well as they are in the
language, or are just great codebases in general to study?

~~~
rekado
GNU Guix. It uses code staging a lot, which works best in a language in which
you can trivially pass around code as data.

It also demonstrates that Scheme is flexible enough to easily implement
features that the language designers did not, such as monads and laziness.
While both can be done in almost any language, I think that Scheme's macros
allow for exceptionally seamless implementations.

~~~
Bromskloss
> code staging

I'm trying to look up what this means. Do you have a link?

~~~
rekado
In Guix not only package definitions are written in Scheme, but also build
phases. These build phases are evaluated at a different time in the context of
the build daemon. This means that there are two major strata, both of which
are written in Scheme. Expressions that are evaluated in the build context
look no different than other expressions.

That's not the only instance of "staged" execution. Guix introduces
G-expressions, a quoted expression in a build context where unquoted package
values are replaced with absolute directory names that are not known until
execution time.

Quoting and unquoting code and dealing with different strata of evaluation
come natural in Scheme.

Another simpler example of staged execution might be the remote code execution
feature of Guile-SSH.

You may also like to read about multitier programming in Hop:
[http://queue.acm.org/detail.cfm?id=2330089](http://queue.acm.org/detail.cfm?id=2330089)

------
gkya
> “Lisp doesn't look any deader than usual to me.” > — David Thornley, reply
> to a question _older than most programming languages_

Oh I like this one (emphasis mine) :)

------
suprfnk
For those looking for a quick overview of the language, I like this website:

[https://learnxinyminutes.com/docs/common-
lisp/](https://learnxinyminutes.com/docs/common-lisp/)

------
FullyFunctional
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.

~~~
lispm
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.

~~~
progman
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/](https://common-
lisp.net/project/mcclim/)

~~~
erikj
McClim existed for decades and it's still struggling to become production-
ready, a poor example of the "revival".

~~~
progman
> it's still struggling to become production-ready

McClim is not a business case. It is just a project to revive the most
sophisticated GUI for Lisp. The graphical shell [1] for instance which already
works gives a remarkable impression.

[1] [https://common-
lisp.net/project/mcclim/static/media/screensh...](https://common-
lisp.net/project/mcclim/static/media/screenshots/listener1.jpg)

------
edem
I did Peter Siebel's tutorial which is suggested at the bottom some years ago
and it gave me that "profound enlightenment experience". Great stuff.

------
wodenokoto
Any good introductions to datascience/NLP/ML or AI using LISP?

~~~
kgwgk
Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp

[http://norvig.com/paip.html](http://norvig.com/paip.html)

~~~
bhnmmhmd
This book is very very _very_ old. It basically belongs to an era when AI was
mostly concerned with symbolic computation. AI nowadays has taken a whole
different path with neural networks.

~~~
lispm
There is very little actual AI in neural networks. Most of the applications I
have seen are in signal processing, pattern recognition, ... For example there
is very little reasoning capability in neural network applications going on.
Show a child two dogs and it will recognize most dogs from now on and you can
ask it why it thinks something is a dog. Try that with neural networks after
showing it a zillion dogs...

Doing anything more AIish will need an old-fashioned symbolic system and that
stuff is still hard. Take for example IBM's Watson. It's a big system with all
kinds of different modules. The language frontend is written in old-fashioned
Prolog.

~~~
ghosthamlet
I agree with you partially. But we still don't know how exactly does human
brain work and learn. Maybe Computer AI as silicon based life will go on a
path different from human.

------
dmytrish
The home page looks like a tombstone of Common Lisp with a bunch of epitaphs
on it.

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;
    

What JavaScript has fixed compared to Lisps?

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.

~~~
bhnmmhmd
There was a discussion here about how Ruby is an acceptable Lisp:

[http://www.randomhacks.net/2005/12/03/why-ruby-is-an-
accepta...](http://www.randomhacks.net/2005/12/03/why-ruby-is-an-acceptable-
lisp/)

Ruby blocks cover a lot of what Lisp macros do. I don't know much Python and
JS, but I'm guessing those don't have something similar to blocks/macros.

~~~
gkya
Python's syntax is incredibly rigid. I'll only write in Python if I don't have
no choice, or I'm paid decent money. I do like the ecosystem of the language
tho, it has everything you'd like to write small utility scripts without
reinventing the wheel. But Perl has them too, and I like the programmer-first
nature of the language, so I use it for my scripting these days. I miss the
pleasant debugging and incremental programme building of Elisp and CL in it,
but I guess it's not impossible to have sth. similar in Perl, some sort of
inferior-perl mode.

------
agumonkey
Tell me it's a PHP backend

