I've been hiring and wildly advertising Lisp jobs for around 10 years now in all sorts of domains. Good candidates always come by, but you'd think that sentiments like yours ("hard to find a lot of jobs") would mean that supply is significantly greater than demand. There is enough supply (if your employer doesn't have lots of stipulations like local-only, citizen-only, etc.; unfortunately mine does), but it's still counter-intuitive to me that supply isn't overwhelming.
I find most people who are attracted to the jobs are
1. Long-time lispers who are pretty happy with their life as it is, and would only take the job if it was truly a killer deal (e.g., work a couple hours a week at a FAANG staff-level full-time salary);
2. College students who are fascinated with programming languages and have dabbled in Lisp; and
There are others, but those dominate in numbers.
I've never, not once, got an applicant that said, "I don't know Lisp but I'd love a job with an interesting language."
Not so remarkably, Haskell programmers, Clojure programmers, and others of those ilk rarely apply. I don't know why, but Lisp has a distinctly different philosophy and lacks a solid community like those languages have.
I've sort of come to the conclusion that advertising it as a Lisp job is perhaps not even so beneficial these days. My biggest success honestly has been finding people who are obviously good at programming, showing them Lisp, then seeing them take off in less than a week and fly to new heights.
I probably wouldn’t ever apply to a role that’s in a niche language I’ve never used. Most niche roles I’ve seen though want staff/principal level domain experts though.
Last time I looked for a job in a niche language (Erlang in my case) most of what I could find was actually looking for Clojure or Scala developers or something, but decided to keyword dump every functional language they’d ever heard of.
I don’t know Lisp and I’d love a job with an interesting language - but it would never occur to me to apply to a job requiring experience with a language that I don’t have experience in.
(Also, functionality is more of a continuum than a binary category. CL certainly is more functional than Python, but less functional than Scheme or SML. It all depends on where you draw the dividing line, though I’d argue that classifying CL as ‘non-functional’ makes for more meaningful categories.)
Some schemes (e.g. Racket) provide immutable data structures.
So I guess Scheme is slightly more functional than CL but with the exception of call/cc the differences are so minor that it doesn't matter.
Common Lisp at least has lexical scope and first class functions.
This is very nice with constants. A function can make a hard dependency on standard out for example. If I change that value locally then call the function, it will operate as expected while everything else using that variable name will continue using their own expected values too. Lexical scoping would instead require passing that value in every time it is used.
Hmm, perhaps I’m misremembering — I know very little about the history of Lisp. I was thinking specifically about the very beginning of the language, where it could be used to define ‘eval’ and nothing much else.
http://bitsavers.org/pdf/mit/rle_lisp/LISP_I_Programmers_Man...
It's not ergonomic to compose functions in the way that Haskell is due to Lisp's forms essentially making every function able to accept a variable number of arguments. You end up with something like arnesi which provides these functions but it gets slow and verbose to write all those `funcall`'s everywhere. Or you have macros.
Whereas in Haskell, partial application and composition are first-class in the design of the language.
I really enjoyed programming in CL but I would say that it's one of those languages that let's you try functional programming but it's not the sweet spot for it.
Example: the call stack isn't first class. You can only interact with it through the condition system, which is very limited.
Example: CLOS has a meta object protocol, which is great! But there's no equivalent to the MOP for, say, the language rules themselves (first element in a list in the reader is treated as a function namespace reference, for example).
For example in LispWorks it's possible to look at a snapshot of a stack in a Debugger, later.
That said, I'm all for more first class things. I really just meant that common lisp was ahead of the game on number of first class things.