
Common Lisp homepage - t-sin
http://lisp-lang.org
======
drmeister
This is a very nice web site describing a programming language with
unparalleled expressiveness, power and permanence.

I am heavily invested in Common Lisp. We are developing a programming
environment for designing new materials and molecules called Cando
([https://github.com/drmeister/cando](https://github.com/drmeister/cando))
using Common Lisp as a scripting language. Cando is running on Clasp
([https://github.com/clasp-developers/clasp](https://github.com/clasp-
developers/clasp)), a new Common Lisp implementation that interoperates with
C++ and is based on LLVM.

What attracted me to the language, after 35 years programming in almost
everything else, was how organically it lets one write software and how I
don't have to worry about it fading like the next programming fad.

~~~
oblio
> how I don't have to worry about it fading like the next programming fad.

I'm not sure I understand this bit. What other programming language has
"faded" and how has it "faded"? At least since the more mature age of
software, which I'd say started around '95 or so (so 20+ years).

~~~
vesak
Pascal, perl, ASP, every ML, Fortran, Cobol, Eiffel, Modula, all "4GL"
languages.

~~~
oblio
If by ASP you mean classic Visual Basic, I'll grant you that. And Pascal.

But ML, Eiffel and Modula were never mainstream.

And Perl, Fortran, Cobol probably still have more programmers out there than
Common Lisp has :)

~~~
deepaksurti
And the fewer CL programmers will run circles around P, F, C programmers :-)

~~~
jabl
So, why don't they? ;)

Why is viaweb and ITA trotted out decade after decade? If CL is so awesome why
isn't the world filled with awesome stuff implemented in CL?

(To be clear, IMHO it's a huge shame that more powerful languages like CL or
Haskell aren't more popular)

~~~
nickpsecurity
Because they won't put in the effort to just pull up and post the customer
lists of companies selling LISP commercially. ;)

[http://www.lispworks.com/success-
stories/index.html](http://www.lispworks.com/success-stories/index.html)

[https://franz.com/success/](https://franz.com/success/)

The companies that use LISP don't talk about it much. I'm not saying secret
weapon or anything either. I'm saying they seem to be among the set that just
identifies something good for the business, buys/builds it, and solves
business problems. They don't write articles about their programming language.
What I will say is the small number of case studies on those two companies
have _much more interesting_ software than what's advertised for many stacks.
The kinds of things people use it for corroborates the LISP advocates' claim
it's a favorite for hardest, constantly-changing problems. It's more
remarkable with Allegro since they charge royalties on top of the licensing
with customers still buying their stuff.

~~~
vram22
Interesting points.

>It's more remarkable with Allegro since they charge royalties on top of the
licensing with customers still buying their stuff.

Do you mean that (apart from the licensing) they also charge a percentage of
the revenue or profits that their customers make from products they develop
using Allegro's products?

~~~
nickpsecurity
It looks a bit different than the last description i saw. Here's current
offering:

[https://franz.com/products/licensing/commercial.lhtml](https://franz.com/products/licensing/commercial.lhtml)

They aint cheap or simple with the licensing. People still are buying it,
though.

~~~
vram22
Good info, thanks.

------
susam
Lisp is quite popular at my current workplace. A few popular open source
projects published by our organization have been written in Clojure (a dialect
of Lisp that runs on JVM and CLR). A few domain specific languages used
internally in our organization are also inspired by Lisp.

On a more personal front, I find Lisp to be simple, elegant, and expressive. I
use Common Lisp (SBCL) for personal use. Working with Lisp induces a sense of
wonder: how simple concepts can be composed elegantly to build complex
functions and complex software. It's the same kind of sense of wonder one
feels when one learns how the simple concepts of Euclid's postulates can be
used to prove complex concepts in Geometry or how the Newton's laws of motion
can be used to derive intricate and complex concepts in classical physics.

I sometimes wonder why Lisp has not been more popular in the technology
industry. Is it the lack of sufficient marketing? Is it the lack of an
extensive library ecosystem? I hope Quicklisp will address the concern about
library ecosystem for Common Lisp.

I encourage everyone to learn Lisp and, if feasible, write a rudimentary
interpreter or compiler for Lisp s-expressions. It's one of those things that
can broaden's one horizon in the field of computing.

~~~
FractalLP
I'd say several reasons: 1.) a lot of folks have trouble with the abstactness
2.) a lot of folks think C syntax is how all languages should be 3.) the lisp
ecosystem is fractured into too many lisps like SBCL, Clojure, Racket,
Allegro, Franz, Picolisp, ABCL, Shen...etc, so some confusion amongst those
that are new 4.) poor windows support for SBCL...it literally tells you it is
experimental if I recall correctly. Setup wasn't straightforward 5.) tooling
is complex and emacs is recommended for both SBCL & Clojure, which is arguably
more difficult than hitting run in most modern IDEs 6.) multi-core seems to
only be in Clojure 7.) lack of decent libraries. There is always someone quick
to say that this is false and that they have everything you need, but coming
from Python and Perl's CPAN, I couldn't disagree more 8.) learning resources
are very hit or miss. I found it hard to pay attention to many of the top lisp
books because a lot of the examples such as building an mp3 database would be
one line of code or two in python. Of course they're just trying to show
concepts and terse expressions isn't where lisp shines, but the effect is
underwhelming. 9.) your fellow developers won't use it and a large company
will probably have an IT department that won't let you run in production
without it being far better known: Java, C#, Python, R, C++, Perl, Ruby,
JavaScript...etc without major pushback...notice how many people equate lisp
with personal projects?

~~~
mtreis86
6 - what about [https://common-lisp.net/project/bordeaux-
threads/](https://common-lisp.net/project/bordeaux-threads/)

~~~
flavio81
... or STMX, which provides software transactional memory on Common Lisp in an
ultra-easy-to-use way.

~~~
FractalLP
I'll definitely take a look at that, thank you!

------
gibsonf1
I highly recommend Eitaro Fukamachi's caveman2 for _very_ quickly setting up a
very fast lisp web server including very easy to configure ssl. Fukamachi's
Dexador library is also fantastic for very quick and easy ssl http
functionality.
[https://github.com/fukamachi/caveman](https://github.com/fukamachi/caveman)
[https://github.com/fukamachi/dexador](https://github.com/fukamachi/dexador)

------
pure-awesome
What exactly is meant by the line "Design patterns disappear as you adapt the
language to your problem domain."

The word "disappear" is a hyperlink to a pdf, which refers to domain-specific
design-patterns. I don't quite seem to grasp what is being implied on the
home-page.

Is it something like Lisp is very customizable and allows you to easily
overload operators? (I am primarily a Java programmer and have never used
Lisp).

 _EDIT:_ I mean, e.g. this page asks "Are Design Patterns Missing Language
Features"
[http://wiki.c2.com/?AreDesignPatternsMissingLanguageFeatures](http://wiki.c2.com/?AreDesignPatternsMissingLanguageFeatures)

Is this what's being referred to, and if so, what makes Lisp especially good
for adding language features?

~~~
giancarlostoro
Indeed Lisps claim to fame is how much the language itself is extensible.
Something along the lines of "you rewrite the language / expand it" for
whatever project you're working on. Writing your own lisp interpreter is
another popular type of project people do as well given how simple Lisps
syntax is to parse and follow.

If you are interested in Lisp on the JVM check out Clojure.

~~~
lispm
For Lisp on the JVM there is also ABCL, which is a full implementation of
Common Lisp: [https://abcl.org](https://abcl.org)

------
joncp
What's with the full-page splash that just says "Common Lisp" with no
indication that you need to scroll to get to the content. This is worse than
the 1990's "Click here to enter the site" silliness.

~~~
city41
I think this trend really took off with Medium, which encourages large (and
useless) banner images at the top of articles. It's an unfortunate trend. It
probably also increases bounce rate if I had to guess.

------
lunchladydoris
If you fancy giving Lisp a try, look into Portacle [0]. I've not used this
exactly but I did install all the components myself over time and they play
together nicely.

[0]: [https://portacle.github.io/](https://portacle.github.io/)

------
mark_l_watson
Nice web site! I have been using Common Lisp since 1983 when I updated my
Xerox 1108 Lisp Nachine.

In the last 35 years I have probably only averaged using Commin Lisp for about
10% of my development but still love the language.

One problem the Lisp world has is too many fine implementations of dialects of
different Lisp languages. I find it impossible to not experiment with most of
them.

~~~
xyrouter
What insights do you gain by experimenting with different implementations of
Common Lisp? Can you share some of those insights or things you learnt by
experimenting with different implementations of Common Lisp?

~~~
mark_l_watson
I don’t have much to say about different versions of Common Lisp. I have
mostly been using SBCL for years, except sometime switching to Clozure for
faster compilation.

I experiment more with different versions of Scheme: Gambit, Chez, and Guile.
I really like the Racket ecosystem - a lot of good work is done around Racket.
I don;t much use Clozure (except for my hobby site cookingspace.com) unless I
am using it because that is what a customer uses.

Church, for Probabilistic programming is interesting but it was apparently
been supplanted by WebPPL(which is not a Lisp).

------
ssijak
Any advantage to learning Lisp instead of something like Elixir today? I find
Elixir to be modern, a large amount of libraries, larger and active community,
BEAM VM, has macros also... Can`t think of a reason to invest time in Lisp at
the cost of mastering something Elixir, but maybe I am wrong.

~~~
deathtrader666
I'm in the same boat as you.

~~~
hajile
You can have your cake and eat it too

[http://joxa.org/](http://joxa.org/)

[http://lfe.io/](http://lfe.io/)

------
susam
Often those who are curious to try Lisp are faced with a number of choices:
Which dialect to choose? Which implementation to choose? Which book or
tutorial should one follow? Is it necessary use Emacs? SLIME?

Here are my recommendations:

\- Choose Common Lisp because it has been the most popular dialect of Lisp in
the overall history of Lisp. It is more convenient than Scheme if one decides
to develop serious software in Lisp. Clojure appears to be more popular in the
technology industry than Common Lisp among organizations (my workplace
included) that use Lisp. I still recommend Common Lisp because I believe that
it is more likely that one would work on an independent open source or hobby
Lisp project than one would encounter one of the rare organizations who use
Clojure at work.

\- Choose SBCL (Steel Bank Common Lisp) as the implementation.[1][2] It is the
most popular Common Lisp implementation and is recommended in many online
discussions. CCL (Clozure CL, not to be confused with Clojure which is a
separate dialect) is also another very good implementation. I still recommend
SBCL because as a result of its greater popularity, it is readily available
via package managers such as brew and apt-get as well IDE packages such as
Portacle, Lisp in a Box, etc. CCL is currently missing from both brew and apt-
get.

\- Work through this book: Practical Common Lisp:
[http://www.gigamonkeys.com/book/](http://www.gigamonkeys.com/book/)
(available in print too if you search online). Skip the sections about Emacs
and SLIME if you don't use Emacs.

\- There is no need to use Emacs if you are not an Emacs user. Any good editor
would do.

\- A Vim user may consider installing Slimv[3][4]. Superior Lisp Interaction
Mode for Vim ("SLIME for Vim") or Slimv is similar to Emacs/SLIME, displays
the REPL in a Vim buffer, and comes with Paredit mode that makes typing and
executing Lisp code quite convenient.

\- Emacs with SLIME or Vim with Slimv are quite useful but not necessary. To
get started quickly without being bogged down by the details of an editor,
just execute the Lisp source code file on shell.[5]

\- Optionally, keep another implementation of Common Lisp. Common Lisp is a
standard that is implemented by various implementations. Each implementation
may have its own extensions or implementation-specific behaviour regarding
error handling, command line options, FASL format, unspecified behaviour, etc.
Experimenting with concepts with another implementation of Lisp occasionally
may offer some perspective about how some things could be different in
different implementations. I keep CLISP around for this purpose.[6][7][8]

[1]: Install SBCL on macOS: brew install sbcl

[2]: Install SBCL on Debian-based distro: apt-get install sbcl

[3]: Slimv in a ZIP file:
[https://www.vim.org/scripts/script.php?script_id=2531](https://www.vim.org/scripts/script.php?script_id=2531)

[4]: Slimv as a Git repo:
[https://github.com/kovisoft/slimv/](https://github.com/kovisoft/slimv/)

[5]: Load (execute) code in a file and exit: sbcl --script foo.lisp

[6]: Install CLISP on macOS: brew install clisp

[7]: Install CLISP on Debian-based distro: apt-get install clisp

[8]: Unfortunately CLISP is missing from Debian's _stretch_ (stable)
repository but it is available in its _buster_ (testing) and _sid_ (unstable)
repositories. Hopefully this will be addressed when _buster_ becomes stable.
CLISP is available on Ubuntu.

~~~
thibran
What confused me a lot is that nobody seems to give an example on how to build
a binary out of a Lisp program/make it runnable from command-line.

Also most tutorials/books I found don't guide you on how to build an
application/structure your code – which is rather confusing for a beginner.
You have to spend a lot of time and try and error to get things working using
Quicklisp. I got often the impression, that since Lisp is so old, everyone
using it knows how to do things and forgot to document for newcomers their
knowledge.

~~~
pavelludiq
The reason nobody can give you an example for how to make a binary is because
there are many many different ways of doing that. To name just a few:

* in ABCL you would generate a jar file, just like with java or clojure

* in SBCL you could dump a core file, there are some tools that can package that up in a command line binary

* if you use a bytecode compiler(like clisp), you'd use that the same way like python or ruby, you'd put your script in a text file, with a #! line at the top and run it like any other shell script.

* if you use a Lisp->C compiler, you'd generate C code and then compile that with GCC or Visual Studio or whatever

* if you use image based programming, you'd just load your code in the lisp image and just use lisp itself as your command line, your "binary" would then be just a normal lisp function.

* If you're deploying a service, you might want to package it in a docker image or even a VM image or have some build and deploy script depending on your environment or needs.

I'm probably missing some, but that's the basics.

------
greymeister
The giant header that fills the first page, forcing a scroll into content, is
right up there with unskippable flash intro videos from 10 years ago.

~~~
giancarlostoro
I'm not sure why this is even a thing, even on news articles with huge images,
it's just POINTLESS to me. "Oh I guess you don't want me to read this article"
_click_

------
elbear
I know the article is about Common Lisp, but I have a question about Racket,
Typed Racket specifically. Can anyone say if types and Lisp play well
together? Are there any success stories?

~~~
rurban
Types are supported since the 80ies, with (the) and optional declarations.
Almost nobody uses them. Well, CL says: types are always carried around in
every value, so we do have types, and we are always type-safe. Which is a
proper point.

Then SBCL has superior internal type support in its python compiler, leading
to many optimizations. It creates specialized copies of typed methods, and has
a nice optimizer framework to deal with that.

Felleisen (Typed Racket) seems to hate types, he summarizes it with types make
racket slower, not faster. But he is still developing the only seriously typed
scheme effort. Forgot about Stalin, but if I remember correctly it was similar
to the CMUCL/python type optimizer.

In my dynamic language I've implemented gradual typing with great success
(cperl): more precise, producing better specialized code, faster, detecting
more errors at compile-time and better documentation, so I'm sceptical why
Felleisen has so many problems. But I implemented it with performance in mind
(premature optimization and such), not completeness. Typed php seems also to
go well, also the various JavaScript variants. Just scheme, python and ruby
not so.

~~~
greghendershott
In my experience Typed Racket programs are never slower than their dynamically
typed Racket equivalents. Sometimes they are faster (such as when the program
does a lot of numeric computation).

What _can_ be slower is a _mix_ of TR and R. Because TR protects the boundary
between the two with runtime contracts. Because it wants safety/soundness.

I'm not any kind of gradual typing expert, but, it seems like you could
calibrate speed vs. soundness for boundaries in different ways. TR has
prioritized soundness but it seems like you prefer speed.

~~~
rurban
Well, I do have the same problems between unchecked and checked expressions.
You get the speed only with series of checked expressions, but you have to
cast to any/dynamic/cons boxed type on each boundary. This is the major
slowdown. When the series of expressions is too short, no transformation to
native should be done, because the casting and conversion back and forth is
more expensive than the win by using the specialized ops.

Similarily SBCL/CMUCL has the similar problem with polymorphic explosion of
generating too many methods, which are rarely used. Javascript V8 and friends
solved that better.

My speed comes from avoiding consing, my native types are bitfields. Lisp
types are usually a class pointer for every cons cell. For me certain casts
are permitted, which are not permitted with Typed Racket. So yes, I have to
permit traditional code which worked before, esp. with inferred types from
literals. Racket has the advantage of defining stricter language subsets,
which we only have with Perl 6 also. There you can override even language and
type semantics.

Chez has a nice tagging scheme, which should speed up Racket a lot.

Several gradually typed languages don't infer from literals, but that's one of
the best speed gains. E.g. the literal 1000 is a union of int32, int64, uint32
and uint64, all possible valid integer types for a certain value. A negative
number cannot be unsigned, and a too large number cannot be 32bit. Problem is
that people rarely add types, you need to infer 90% of them.

------
terminalcommand
Great site, seems to have a good collection of lisp resources. I am waiting
for the documentation to go online, it says it is still parsing the TeX
sources of the commonlisp hyperspec.

As a side note, I downloaded the Lispworks Common Lisp Hyperspec, but I could
only find the HTML version.

I see that the project is on Github, maybe someone will parse the Hyperspec
and generate the documentation pages.

I am adding a reminder to my org-agenda for next month, maybe I will attempt
to do it :).

~~~
hjek
It looks like the Hyperspec license doesn't permit distributing documentation
pages:

> Permission to make partial copies is expressly NOT granted, EXCEPT that
> limited permission is granted to transmit and display a partial copy the
> Common Lisp HyperSpec for the ordinary purpose of direct viewing by a human
> being in the usual manner that hypertext browsers permit the viewing of such
> a complete document, provided that no recopying, redistribution, redisplay,
> or retransmission is made of any such partial copy.

Source:
[http://www.lispworks.com/documentation/HyperSpec/Front/Help....](http://www.lispworks.com/documentation/HyperSpec/Front/Help.htm)

But I guess you could distribute a script that does the processing.

~~~
draven
Reading the whole thing it seems you're allowed to distribute it as is without
changing anything, and not getting any commercial advantage out of the
distribution.

There's this: [https://github.com/LispLang/ansi-
spec](https://github.com/LispLang/ansi-spec)

Working from the TeX sources seem to be the right way to go especially if the
information can get extracted into a generic representation so there could be
a HTML / epub / whatever version

------
nerpderp83
This is _not good_ , the info density for the screen area is too low. This
could have been one maybe two screens worth. Is this the credits to Friends?
Am I consuming Lisp Content while chillin in my penthouse on my 20k couch
using a gold plated IPad X Tablet?

Millennials are Killing Common Lisp.

one page, [https://www.rust-lang.org/en-US/](https://www.rust-lang.org/en-US/)

~~~
giancarlostoro
The Racket-Lang site almost had it perfect:

[http://racket-lang.org/](http://racket-lang.org/)

The stuff above the language description should be shoved to the bottom
(excluding obviously the top menu) and it would be perfect. I miss their old
site because it was obvious and to the point and had examples right away.

~~~
jwilk
Huh? If I exclude completely uninteresting "Racket School 2018" announcement,
I have 18 words (plus some pointless images) on the first screen.

Oh, apparently I'm supposed to hover over the images to see more text. Why?!

~~~
giancarlostoro
I mean exclude those too and the page looks much better.

------
vram22
Is there any official (other than any ANSI standard site) or quasi-official or
unofficial main site for Lisp or Common Lisp?

I had seen a couple of other sites which _seemed_ like they might be that
earlier, like [https://common-lisp.net/](https://common-lisp.net/) and the
site of the Association of Lisp Users, which I vaguely remember as being at
[http://alu.org](http://alu.org) , but now a Google search shows some other
sites instead (from the first few hits I looked at). And now there is this one
mentioned in the OP. I looked at its About page, [http://lisp-
lang.org/about/](http://lisp-lang.org/about/) , but it does not seem to show
any such info.

Update: I saw this on the common-lisp.net site:

"This site is one among many gateways to Common Lisp."

which seems to indicate that there was/is no single "(un)official" one.

~~~
pavelludiq
Where is C's (un)official home page?

------
lispm
For those who want to use Lisp on the JVM, there is ABCL:

[https://abcl.org](https://abcl.org)

ABCL was originally used to write and extend an editor called J - but then
morphed into a full implementation of Common Lisp.

One can also develop with SBCL - since it has a great compiler - and then move
the code to ABCL.

~~~
estsauver
There's also clojure on the JVM.

~~~
lispm
Note though that Clojure is not compatible with Common Lisp, thus the
information from the 'Common Lisp homepage' linked here is not applicable.

------
kunabi
At the request of John McCarthy, Lisp’s creator, no single language that is a
member of the Lisp family is to be intended to be the definitive dialect; that
is, none is to be called just “LISP.”

So much innovation has happened since the CLHS that to put up a fluff site
feels like an effort of "resurrection". When in reality the Lisp family has
continued to evolve since then. To limit yourself to just CL, as I did, for a
long time, results a bit of a 'losing my religion'. You'll be confounded by
things long since solved, and in the end perhaps write all of "Lisp" off. Do
yourself a favor and keep and open mind to the family, and not one common
incarnation that predates some developers.

~~~
drmeister
"Fluff" "FLUFF"??? If that's fluff then most of the rest of the web is
fluff... oh wait.

Seriously, the web site is a very informative site about "Common Lisp" \- a
specific dialect of Lisp. It's right there when you click the link, big
letters - "Common Lisp" \- you can't miss it.

You could argue about the URL "lisp-lang.org" \- but why?

~~~
WindowsFon4life
"We are in the process of decoding the original format used for the CLHS."
This is a smell that highlights the above post it seems.

~~~
drmeister
It's more of an issue at the interface of technology and licensing. The CLHS
(Common Lisp Hyper Specification) is a very large, web based document written
in the 80's and it looks like an old Geocities web site. I believe the CLHS
license says that it's not allowed to be changed (to protect the standard - I
believe - someone correct me please) and so the community is working from
slightly older drafts and figuring out how to automate the conversion to
something that looks more modern. It's not a problem with Common Lisp - it's a
problem that HTML, the web and user expectations have been changing over the
years. There's that permanence thing again.

~~~
lispm
> is working from slightly older drafts

Not really, the content is the same.

------
ungzd
Is main page created with Powerpoint? /learn/ is good (better than nothing or
than ancient PDFs) but no real documentation yet.

------
FractalLP
[http://lisp-lang.org/success/](http://lisp-lang.org/success/)

------
arf
Is there a way to find well-maintained non-broken preferably-actively-
maintained libraries or those that the community considers to be the de facto
solution? Like where would I start with doing data science or web dev (and
related subjects like encryption and auth etc) or things like async or
parallel programming?

------
ktosobcy
Why the "Fast" section (or graphs on
[https://github.com/fukamachi/woo](https://github.com/fukamachi/woo)) don't
contain any JVM based solutions? Anyone has idea how do they compare?

------
mping
My AI class teacher was one of the founders of Siscog. I learned scheme and
lisp at college too. Glad to see his company being mentioned.

~~~
gbl08ma
You might be pleased or displeased to know that at Técnico they no longer
teach Scheme in the introductory programming course, nowadays it's Python.
When I did the AI course, the project was still to be developed in Lisp, but
more recently I recall hearing that they were thinking of switching to another
language because "nobody can stand lisp". Fun fact: one of the founders of
Siscog, Ernesto Morgado[1], is big in the rice business, and is/was the
president of multiple rice millers associations. Both Pavão Martins and
Ernesto Morgado still lecture at Técnico.

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

~~~
mping
In hindsight, displeased for sure.

------
minieggs
Great to see a pretty Lisp site up. Loving it.

------
agentultra
Nice site!

I bought cdr.io years ago when I was seriously into Lisp. If anyone has an
idea for it, happy to pass it along.

------
djhaskin987
Any good implementations if common lisp on Windows?

~~~
orthecreedence
Clozure CL ([https://ccl.clozure.com/](https://ccl.clozure.com/)) is the
counterpart to SBCL on Windows. I never had much luck with SBCL on Windows
(granted, I haven't tried in about two years) but Clozure CL always worked
fantastically (including threading, FFI, etc).

------
xyproto
(mapcar #'string-downcase (list "Hello" "world!"))

This is a great example of why I don't want to use Common Lisp.

Compare with Python:

[word.lower() for word in ("Hello", "world!")]

Beating Node and Ruby in terms of speed is also a big non-argument, with so
many attractive programming languages to choose from that are both fast and
good looking.

~~~
klibertp
Can you elaborate on why?

I know both Python and Common Lisp, neither version looks any better than the
other to me.

Also, as another commenter notes, the snippets are not actually good
translations of each other. Your CL snippet would look like this in Python:

    
    
        list(map(str.tolower, ("Hello", "world!")))
    

While your Python snippet would look like this in CL (as pavelludiq notes):

    
    
        (loop for word in '("Hello" "world!") collect (string-downcase word))
    

Granted, Lisps tend to be a bit more verbose (longer names, less symbols
used), which is a natural consequence of having little syntax. It has serious
advantages when learning the language or when reading unfamiliar code,
although it comes with some drawbacks, too.

~~~
svetlyak40wt
Actually, lisp varian can be also a:

    
    
        (mapcar #'string-downcase '("Hello" "world!"))

