Common Lisp Books(lisp-lang.org) |
Common Lisp Books(lisp-lang.org) |
Moreover, I was expecting to see "Paradigms of Artificial Intelligence Programming", from Peter Norvig. I have not fully read it, but it seems to be an awesome book. Not just to learn Lisp but a good book in general, since the code is beautifully designed. Despite the title, AI (GOFAI, actually) is just the domain, the lisp techniques and code approach can be applied to other areas.
This Reddit's post presents another list that might be an interesting complement to the one we are discussing here: https://www.reddit.com/r/Common_Lisp/comments/ddcoar/selecti...
What I found really useful was to work through the excersizes in a proper SLIME setup in Emacs with paredit. Since the excersizes were easy enough I could instead focus on learning to use a proper development setup for working with Lisp.
I've helped on the ongoing work of ebook cleanup.
(Disclosure: I was the technical reviewer for the former and I wrote the latter.)
Functional programing is still awesome, but for high-level work I think the multiparadigm languages like Scala, Swift, and CL are the way to go.
A self plug: you can get free PDF/ePub/Kindle versions of my Common Lisp book on my personal web site (https://markwatson.com)
And, shameless plugs: a web project skeleton: https://github.com/vindarel/cl-cookieweb (very new), a demo of hot reloading a running web app (locally or deployed): https://github.com/vindarel/lisp-web-live-reload-example
I'm not sure it's worth it unless you just want to write CL almost exclusively. It's cool though to have more variation on different deployment (or even "do it in production") workflows available to fit your tastes, from something like PHP's/CGI's copy/edit files loaded each request, to a more conservative shutdown-deploy-restart cycle, to connecting via SSH and then inspecting/debugging/editing the live program through a forwarded REPL socket in your favorite editor just as if you were doing it locally.
I started with a simple .org file. Whenever I encountered a problem, a question, or a confusing topic, I would simply add a todo heading.
Over time, I slowly learned Org-mode, then Babel, then transitioned to Org-Roam. I learned enough of Emacs Lisp, then learned Clojure, then tried other Lisps like Fennel. Today, I'm comfortably writing my own little elisp packages, sharing tips with my colleagues, chasing performance bottlenecks, and still learning.
Just start with a simple todo list.
By the later part of it I felt like I had a decent handle on Emacs Lisp and could read the code for packages I was interested in reasonably well.
I just recently read the book for Klong by Nils https://t3x.org/klong/book.html
Worth it!
Especially this part, from toward the beginning:
> Before I get into the details of what Y actually is, I'd like to address the question of why you, as a programmer, should bother to learn about it. To be honest, there aren't a lot of good nuts-and-bolts practical reasons for learning about Y. Even though it does have a few practical applications, for the most part it's mainly of interest to computer language theorists.
The article goes on to explain why you should learn it, anyway, but, still, it's not like monads and Haskell. Despite the concept's intellectual cachet, you don't need to understand it to be an effective lisper. That said, this opinion is mine and mine alone, and stands in direct contradiction to the sentiment expressed in the following paragraph.
There is a paper, Y in Practical Programs ( https://blog.klipse.tech/assets/y-in-practical-programs.pdf) that presents some interesting things you can layer on top of the technique. I'll leave it up to others to debate whether doing so is genuinely practical, or more of a game of functional code golf.