The Little Typer (Mit Press)

: )

I’ve been (slowly) working my way through The Little Typer. It’s a deep dive on dependent types, starting with the very basics and building up a toy language one step at a time. I can feel it gradually changing how I think about programming (heck, how I think about thinking).It’s really, really enjoyable. The format is very approachable, even fun. Rigorous and demanding, yet doesn’t take itself too seriously. Some lisp experience is helpful, but probably (maybe?) not necessary. But do yourself a favor and learn lisp anyway ;-)If you’re someone who is already proficient with dependent types, Idris, Coq, etc it might be too basic for you - but it never hurts to solidify your foundations, right? Or maybe wait for The Seasoned Typer ;-) Overall, two thumbs up, highly recommended.

Let me be clear; this is not a book for everyone. It did happen, though, to be *exactly* the right book for me. It's written, like the other books in the "Little X-er" series, in the form of a dialogue between a teacher and an (extremely good) student. This means that every point in the book invites you to figure out what the answer should be for yourself; this kind of mental struggle is incredibly valuable in learning material and making it your own.The topic is Type Theory; specifically, the kind of intuitionistic type theory that underlies languages like Agda, Idris, and Coq. This book provides a lovely gem of a language (pie) in which to explore these ideas. If you're interested in proof-oriented languages like these and you have substantial familiarity with functional languages, I HIGHLY recommend this book.

This book will challenge the way that you think about coding.I have started to think different as a result of this book. There's subtle advice and guidelines all over the place. It's best to read chapters more than once.Constructirs, eliminators, and I'm pretty sure combiners will soon follow. Simple but such important concepts.

The way this book teaches a complex topic like dependent types is just fantastic. If you take the time to read through each frame and think about the next frame before you read it, you'll learn so much and so well. Take the time to read and understand every frame. Highly, highly recommended.

A nice and simple introduction to a complex topic. Could be a bit tedious for someone just wanting to come up to speed with DTs. Overall five stars without a doubt.

Following the "Little Schemer" series, this book introduces under the form of a dialogue, and using a toy language, the mysteries of dependently typed languages. Both extremely pleasant to read and challenging.

If you like the conversational style of education, with a back-and-forth between teacher and student, with information slowly hinted at for self revelation, then this book is for you. If you want a book that gets to the point and just tells you the information in a clear format, this is probably not the best book for you.

I read The Little Lisper when it first came out in the 1980s and it was one of the reasons I became a professional programmer. Either you like the style or you don't, but I really do.The Little Typer is written in the same style and introduces a subject that seems insanely complicated in most of the texts, but like The Little Lisper, this book gently takes you from a very easy start to some heavy duty stuff.That said, you do need to understand Scheme and have a reasonable acquaintance with functional languages before you start. Maybe read The Little Schemer and have a play with Haskell before you start reading this.And avoid the Kindle version. You'll end up paging backwards and forwards to see the frames - really frustrating.

This book is not for everybody, but it just could not be. Dependent types can be said to be hard, but this book does an incredible job of explaining them nonetheless.Highly recommended if you're interested in dependent types.

Great.

I had been a programmer for years, but I didn't really understand what evaluation was until I read Abelson, Sussman and Sussman's 'Structure and Interpretation of Computer Programs'.This book has done the same to me for types. Its dialectic style might not be to everyone's taste, but it certainly was to mine. Its steady, precise and complete description of dependent types has given me a new understanding of what type checking actually is.

Some people really like this book, some, like me, find it pretty tedious.It's written like the transcript of a tutorial, listening to somebody asking lots of questions.... in other words, you have to read it carefully and in order. You can't use it as a reference, and you cannot learn at your own pace learning concepts in the order you choose. So if like me you know some of this stuff but not all of it, I think you'll find it irritating. Also, it uses it's own dialect of Scheme, so you have to learn that as you go along.For someone who wants to learn quickly, this isn't the place to start. For somebody who wants their hands held - or wants their hands tied - it's fine.So before buying it, borrow a copy and decide if the unusual style suits you or not.