Short answer: Yes.
Long answer: No!
I learned Lisp and TI-Scheme in the early 80s, and somewhere around then we did some SICP-like stuff in undergrad CS.
I later came upon SICP and worked my way through it, having the usual "Aha!" moments. I thought I knew something about Lisp and Scheme at that point. I built some self-hosted interpreters using the following pattern:
1. Write an interpreter for a minimal subset of Scheme in a host language.
2. Write an interpreter for a more full-featured Scheme in the subset of Scheme.
At some point, I read LiSP [0], and I discovered that what I thought was enlightenment was actually but a hint of the delights to come. The entire book is about teaching programming through the device of building interpreters and compilers.
So my next pattern was something like:
1. Write a minimal Scheme interpreter in a host language.
2. Write a Scheme compiler in Scheme.
3. Bootstrap the compiler by running in in the interpreted Scheme.
4. Now you have a compiled Scheme implementation written in Scheme.
5. Build out more features.
And now, this approach is one of my go-to tools. A few years ago, I was playing with Turing Machines, and I used a "constructive proof" approach: If we want to demonstrate that a Turing machine with tape that has one end is just as powerful as a Turing Machine with a tape that stretches to infinity in both directions, write a compiler from one kind of Turing Machine to the other. And so on and so forth to prove that being able to write an infinite number of different symbols is no more powerful than writing 0s and 1s. Or that a multi-dimensional Langdon's Ant is no more powerful than a Turing Machine...
Interpreters and Compilers are very powerful tools for constructive reasoning.
But the point of the discussion around Scheme for this purpose is how easy it makes writing Interpreters and Compilers. On the one hand... Shrug... Since we can write interpreters and compilers in any language.
On the other hand, a tool that removes a lot of the accidental complexity in writing interpreters and compilers changes the way we think about writing interpreters and compilers, much as parsing text using a language built around pattern matching (like SNOBOL and its descendants) changes the way we think about parsing text.
So... We are probably in deep agreement about the value of SICP in Scheme, and the value of Lisp in general, not just as a language, but as a way of changing the way we approach solving problems.
And as for knowing enough... The truth is, every time I sit down with certain programming ideas, I learn more and realize that what I thought I knew was incomplete.
So in a very real sense, I suspect that no, I don't know nearly as much as I think I know.
---
[0]: Lisp in Small Pieces: https://www.amazon.ca/Lisp-Small-Pieces-Christian-Queinnec/d...
Probably the best deep ground-level explanation of APL is Iverson’s paper “Notation as a tool of thought.” [0]
The bootstrapping explanation you describe sounds a lot like what Paul Graham did in “On Lisp” [1] and in a much more complex fashion, Queinnec in “Lisp in Small Pieces” [2], both highly recommended.
[0] https://www.jsoftware.com/papers/tot.htm
2. Generative Programming (https://www.amazon.com/Generative-Programming-Methods-Tools-...)
3. PAIP (https://www.amazon.com/Paradigms-Artificial-Intelligence-Pro...)
4. Lisp In Small Pieces (https://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/...)
5. The C Programming Language (https://www.amazon.com/Programming-Language-Dennis-M-Ritchie...)
https://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/...
This book goes into some of the more advanced uses of macros and I don't believe most carries over to other "lisps".
I really loved the section on reader macros!! That's a topic that doesn't get enough attention from people coming to common lisp.
I don't believe clojure, for example, supports user defined reader macros, atleast I can't remember it having them the last time I used it(circa 2011).
EDIT, it looks like clojure does have reader macros now. Clojure just keeps getting better:)
http://en.wikibooks.org/wiki/Learning_Clojure/Reader_Macros
In addition to Let over Lambda, my common lisp reading list includes:
http://www.amazon.ca/Lisp-Small-Pieces-Christian-Queinnec-eb...
http://www.amazon.ca/Compiling-Continuations-Andrew-W-Appel-...
and http://www.amazon.ca/Paradigms-Artificial-Intelligence-Progr...
I'd love to hear if anyone else has book recommendations in a similar vein. I'm in the middle of a month off to read books and research papers so this is pretty timely for me:)
Richard Bird - Pearls of Functional Algorithm Design http://www.amazon.com/Pearls-Functional-Algorithm-Design-Ric...
Christian Queinnec - Lisp in Small Pieces http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/d...
Ur-Scheme: http://canonical.org/~kragen/sw/urscheme/
An Incremental Approach to Compiler Construction: http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf
PicoLisp: http://picolisp.com/5000/!wiki?home
Lambda-the-Ultimate papers: http://library.readscheme.org/page1.html
SICP: http://mitpress.mit.edu/sicp/full-text/book/book.html
LiSP: http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/d...
Maru: http://piumarta.com/software/maru/
Edit: You might also enjoy Jonesforth (see jonesforth.S): http://git.annexia.org/?p=jonesforth.git;a=tree
The book is in two parts. The first starts from a simple evaluation function and enriches it with multiple name spaces, continuations and side-effects with commented variants, while at the same time the language used to define these features is reduced to a simple lambda-calculus.
The second part focuses more on implementation techniques and discusses precompilation for fast interpretation: threaded code or bytecode; compilation towards C. Some extensions are also described such as dynamic evaluation, reflection, macros and objects.
Note that Peter Norvig gives it a five-star review.
(The affiliate link benefits DuckDuckGo.)
Take a look to Lisp in Small Pieces[1] if you are interested in something beyond the metacircular evaluator from SICP.
Read the code of Racket, you will learn a lot from it.
[1] http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/d...
1. A Gentle Introduction to Symbolic Computation. http://www.cs.cmu.edu/~dst/LispBook/index.html
2. Practical Common Lisp http://www.gigamonkeys.com/book/
3. ANSI Common Lisp http://www.paulgraham.com/acl.html
4. On Lisp http://www.paulgraham.com/onlisptext.html
5. Paradigms of Artifical Intelligence Programming http://norvig.com/paip.html
6. Lisp in Small Pieces http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/d...
SICP is also amazing...and there are at least three sets of videos to go with the book (Abelson/Sussman and HP/MIT, ArsDigita, and UC-Berkeley.)
It starts with a very minimal meta-evaluator for something similar to McCarthy's original Lisp, and then explains why all the changes from Lisp 1.0 since were made. Why did language designers change things in the first place? And then it shows you how those differences are implemented. One of the first lessons is the problems with the semantics of dynamic scoping, and the implementation of dynamic vs. lexical environments. I personally worked through the book writing in SML. Despite the name and approach, it's not really a Lisp book; it's a compiler implementation book.