The Little Typer (2018) (opens in new tab)

I’d recommend the earlier book in the series, The Little Schemer, for what it’s worth! It’s more aimed towards beginners. Similar format to this book.

Check this course out:

https://www.edx.org/learn/coding/university-of-british-colum...

I think you'll really like it. It uses Racket and is based upon the How to Design Programs book. It is absolutely perfect for someone new to coding.

> Maybe some day I'll motivate myself to even figure out how to first install Racket/Pie (first, I have to figure out what even these are).

If you're retired and don't need to do the Webrogrammer grind of employable skills, that's a great time to learn advanced/alternative topics of programming like this.

(But if you instead want a paying second career, you probably want to either focus on Web or phone app development instead of this, or have a personal connection to get a job in some less-common area of software development. The Little Typer probably won't help you with that.)

I suspect that the book will do a good job of explaining its topic, from scratch. Here's how to install the software that the book uses:

1. https://download.racket-lang.org/

2. > Open DrRacket and select "Install Package" from the "File" menu. In the package name field, type pie and then click the "Install" button.

I'd say a Lisp and books like little Schemer, etc. are a perfect way to study programming and computer science. Later on you could have a look at SICP (Structure and Interpretation of Computer Programs) which also uses Scheme, but is more advanced than Little Schemer. It's one of my all time favourite CS books.

This is great for me for a completely auxiliary reason, which is that I wanted to know whether this was just gonna be a book about programming Fibonacci numbers into types or some ish... and in some ways it's kinda worse, at chapter 9 you are still proving that different takes on x→x+1 are the same. (But using rewrite rules seems kinda interesting in the abstract I guess.)

I don't think there's a centralized community for the Little Series. I think this is unfortunate. With a community, some great titles like The Little MLer (typed FP) and A Little Java, a Few Patterns (OOP) would be much better known.

I found those two outstanding. I think A Little Java has been reprinted. But last time I checked, The Little MLer was bloody expensive. Standard ML, OCaml and F# need a lot more exposure. They are simple and practical. The Little MLer does a great job introducing the basics.

To close the circle, the Little Series is missing a book about concurrent and distributed paradigms à la Erlang. They already have functional programming, typed functional programming, declarative programming, dependent types, theorem proving, object-oriented programming and machine learning.

You are welcome in the Racket Discord.

https://discord.com/invite/racket-571040468092321801

The Gay Haskell discord server has a channel for dependent types. There is also a discord server for Type Theory Forall, a podcast.

Racket! This is the language that the common author (Dr. Daniel Friedman) uses, and many of the Little books use custom DSLs implemented in Racket.

Racket now runs on Chez under the hood (inheriting the performance), and has a pretty decent ecosystem as far as schemes go.

(I TA for Dr. Friedman’s programming languages course)

I don't know what is the best Scheme implementation, but this book has little to do with Scheme though. Pie uses S-expressions for syntax, and happens to be implemented in Racket, but you don't interact with Racket directly.

This one comes with its own language, "Pie", which you can use in DrRacket with #lang pie

This is the last thing I'd worry about. The series isn't about teaching you a language you can use later in industry. It's about teaching you higher-level concepts you can take with you to any languages you may encounter in the future.

Guile is great, but I think outside Guix it's pretty niche.

Racket is probably the most frequent choice. But I really like some aspects of Chicken, Gambit and Bigloo.

Even Clojure or CL could also be used, with a bit of friction of course.

A book like this doesn’t need to be “practical” and “useful” - I don’t think, say, the shortage of libraries for Chez Scheme is going to hamstring you in anyway.

Guile probably has the best Emacs integration through Geiser. While you don't really need it and you can just follow along with a terminal REPL, using something like Geiser helps keeping the experience smooth.

MIT/GNU Scheme comes with its own editor, edwin, which is a terminal-only Emacs-like. I don't know how much it complies with the various RnRSes, but I do believe it's good enough to work for the Little series.

Gauche is R7RS-small (and I believe -large up to Tangerine) compliant so it should just work. It also has fairly good Geiser support and comes with an enormous standard library, 'batteries included' as they say, though its performance is a bit lower than some of the other implementations.

Cyclone is R7RS-small compliant so it should work. It seems fairly fast and it has a package manager, but because it's fairly new I don't know how well it works with Geiser.

Loko is R6RS compliant so it should work. I believe the documentation says that it should work with Geiser using the Chez module, but I may be mistaken.

Gerbil is R7RS-small compliant (and I believe -large through Red, maybe through Tangerine?) so it should work. I believe it's also quite performant, though I haven't used it.

Kawa is R7RS-small compliant if I'm not mistaken. If so it should work for the Little series. It also has a Geiser module.

And then there are a few implementations of which I'm not entirely sure which version of the spec they comply with and how well they're supported by various editors (though I think SLIME has Scheme support, although that may only be for MIT/GNU Scheme): Gambit (I think R5RS? Gerbil is built on top of it), Bigloo (I think R6RS?), Larceny, Chibi Scheme, Biwa Scheme, S7, and IronScheme. For any of those, as long as they support post R4RS macros (so using `define-syntax' and `syntax-rules' instead of `defmacro)' they should work for the Little series without any adjustments. If they're still using `defmacro' then you'd need to translate the macro definitions from Reasoned (and later?), which isn't that hard... but if you're gonna do that you may want to read On Lisp after Seasoned.

Guile is my Scheme of choice.