The Little Typer (Mit Press): Friedman, Daniel P., Christiansen, David Thrane, Bibby, Duane: 0000262536439: Amazon.com: Books

{"desktop_buybox_group_1":[{"displayPrice":"$54.00","priceAmount":54.00,"currencySymbol":"$","integerValue":"54","decimalSeparator":".","fractionalValue":"00","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"bWlEJQDFSKhCLQuYsIpvnFn15cC%2BT69YZSpekwKHtJbxBiYgwPvaO6HgIb56iYEmNGMA6kP%2BK0TQYIusznshbM%2FPgrVd%2BDYBwDg6R65xe1U%2FSXHkzlp7dgkQMLJp1LAmN9Eu5RAQKb2I%2FeW75FxqboKlHQqZMJmoGHxaUB%2FDWz4WBHtv8%2B5u18jNIJtmDMpl","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$44.82","priceAmount":44.82,"currencySymbol":"$","integerValue":"44","decimalSeparator":".","fractionalValue":"82","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"bWlEJQDFSKhCLQuYsIpvnFn15cC%2BT69Yh%2B8mlL5sAWgWX3BWknNuu8Wl0p%2BHEXevrp8cjDfhCKxRBB9PkA6l20zikcEku59RsYP1Y492gdkfVu9XreECifZhH7kbw%2FzDrliSvnqGeVFKYAI3loJcIGFntuVeAw%2BF2CluEaPtxc6K8LjZaLxAJ%2BwWMdiMqcIt","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}],"desktop_buybox_group_2":[{"displayPrice":"$54.00","priceAmount":54.00,"currencySymbol":"$","integerValue":"54","decimalSeparator":".","fractionalValue":"00","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"bWlEJQDFSKhCLQuYsIpvnFn15cC%2BT69YZSpekwKHtJbxBiYgwPvaO6HgIb56iYEmNGMA6kP%2BK0TQYIusznshbM%2FPgrVd%2BDYBwDg6R65xe1U%2FSXHkzlp7dgkQMLJp1LAmN9Eu5RAQKb2I%2FeW75FxqboKlHQqZMJmoGHxaUB%2FDWz4WBHtv8%2B5u18jNIJtmDMpl","locale":"en-US","buyingOptionType":"PICKUP","aapiBuyingOptionIndex":2}]}

Purchase options and add-ons

An introduction to dependent types, demonstrating the most beautiful aspects, one step at a time.

A program's type describes its behavior. Dependent types are a first-class part of a language, and are much more powerful than other kinds of types; using just one language for types and programs allows program descriptions to be as powerful as the programs they describe. The Little Typer explains dependent types, beginning with a very small language that looks very much like Scheme and extending it to cover both programming with dependent types and using dependent types for mathematical reasoning. Readers should be familiar with the basics of a Lisp-like programming language, as presented in the first four chapters of The Little Schemer.

The first five chapters of The Little Typer provide the needed tools to understand dependent types; the remaining chapters use these tools to build a bridge between mathematics and programming. Readers will learn that tools they know from programming—pairs, lists, functions, and recursion—can also capture patterns of reasoning. The Little Typer does not attempt to teach either practical programming skills or a fully rigorous approach to types. Instead, it demonstrates the most beautiful aspects as simply as possible, one step at a time.

Products related to this item

Page 1 of 1Start overPage 1 of 1

Sponsored

'; var HEADER_STRING = "Leave feedback"; if (false) { HEADER_STRING = "Ad information and options"; } var modalInstance = AM.create(trigger, { 'content': initialContent, 'header': HEADER_STRING, 'popoverLabel': HEADER_STRING, 'name': modalName }); modalInstance.show(); var serializedPayload = generatePayload(modalName); A.$.ajax({ url: "/af/multi-creative/feedback-form", type: 'POST', data: serializedPayload, headers: { 'Content-Type': 'application/json', 'Accept': 'application/json'}, success: function(response) { if (!response) { return; } modalInstance.update(response); var successMetric = DESKTOP_METRIC_PREFIX + ":formDisplayed"; if (window.ue && window.ue.count) { window.ue.count(successMetric, (window.ue.count(successMetric) || 0) + 1); } }, error: function(err) { var errorText = 'Feedback Form get failed with error: ' + err; var errorMetric = DESKTOP_METRIC_PREFIX + ':error'; P.log(errorText, 'FATAL', DESKTOP_METRIC_PREFIX); if (window.ue && window.ue.count) { window.ue.count(errorMetric, (window.ue.count(errorMetric) || 0) + 1); } modalInstance.update('' + "Error loading ad feedback form." + ''); } }); return modalInstance; } function removeModalOnClose (modalName) { A.on('a:popover:afterHide:' + modalName, function removeModal () { var isSuccess = AM.remove(modalName); if(isSuccess) { document.getElementById("sp_detail_feedbackMessage").focus(); } }); } function generatePayload(modalName) { var carousel = CF.getCarousel(document.getElementById("sp_detail")); var EMPTY_CARD_CLASS = "a-carousel-card-empty"; if (!carousel) { return; } var adPlacementMetaData = carousel.dom.$carousel.context.getAttribute("data-ad-placement-metadata"); var adDetailsList = []; if (adPlacementMetaData == "") { return; } carousel.dom.$carousel.children("li").not("." + EMPTY_CARD_CLASS).each(function (idx, item) { var divs = item.getElementsByTagName("div"); var adFeedbackDetails; for (var i = 0; i < divs.length; ++i) { if (divs[i].getAttribute("data-adfeedbackdetails")) { adFeedbackDetails = divs[i].getAttribute("data-adfeedbackdetails"); break; } } if (!adFeedbackDetails) { return; } if (adFeedbackDetails != "" && adFeedbackDetails != null) { adDetailsList.push(JSON.parse(adFeedbackDetails)); } }); var payload = { adPlacementMetaData: JSON.parse(adPlacementMetaData), adCreativeMetaData: { adCreativeDetails: adDetailsList }, feedbackFormContainerId: modalName }; var serializedPayload = { pl: encodeURI(JSON.stringify(payload)) }; return JSON.stringify(serializedPayload); } }); }));

Feedback

&nbsp

Yegor Bugayenko

Object-oriented programming is not what you think it is. This book explains why NULL, getters, setters, static methods, mutability and so on are evil.

Paperback

-6%$38.65
List:$40.96
Feedback

&nbsp

Chris Minnick

Paperback

$24.99
Feedback

&nbsp

Brian J. Wardyga

Paperback

-28%$57.98
List:$79.99
Feedback

&nbsp

Christopher M. Bishop

Hardcover

-10%$81.32
List:$89.99
Feedback

&nbsp

Sandeep Ahluwalia

Dive into Rust internals via generated assembly, covering Rc, Arc, dynamic dispatch, trait inheritance, SIMD auto-vectorization, and async/await.

Paperback

-5%$39.90
List:$42.00
Feedback

&nbsp

Larry D Pyeatt Ph.D.

Paperback

$89.95
Feedback

&nbsp

weili chen

Paperback

-5%$19.00
List:$20.00

Customer reviews

73 global ratings

How customer reviews and ratings work

Review this product

Write a customer review

Customers say

Customers find the book provides a simple introduction to a complex topic like dependent types. They describe it as well-written and beginner-friendly, with an excellent introduction to type theory.

AI-generated from the text of customer reviews

Select to learn more

Pacing Introduction

7 customers mention "Pacing"7 positive0 negative

Customers find the book provides a simple introduction to a complex topic like dependent types. They say it's well-written on a challenging subject and is beginner-oriented. The book treats the subject with levity and fun, like the other books in the Little X-er series.

"...It’s a deep dive on dependent types, starting with the very basics and building up a toy language one step at a time...." Read more

"...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..." Read more

"...Simple but such important concepts." Read more

"The way this book teaches a complex topic like dependent types is just fantastic...." Read more

5 customers mention "Introduction"5 positive0 negative

Customers find the book's introduction to dependent types and type theory helpful.

"...It’s a deep dive on dependent types, starting with the very basics and building up a toy language one step at a time...." Read more

"...The topic is Type Theory; specifically, the kind of intuitionistic type theory that underlies languages like Agda, Idris, and Coq...." Read more

"This is an excellent (and practical!) introduction to dependent types." Read more

"The best introduction to dependent types." Read more

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Juan P
Approachable introduction to dependent types that treats the subject with levity and fun
Reviewed in the United States on December 16, 2019
Verified Purchase

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.

Read more

8 people found this helpful

Helpful

Report
John B. Clements
Exactly the book I've been waiting for
Reviewed in the United States on January 7, 2019
Verified Purchase
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.

Read more

16 people found this helpful

Helpful

Report
Jonathan Visona
As Promised
Reviewed in the United States on September 22, 2024
Verified Purchase
: )

Read more

Helpful

Report
Aaron Lelevier
This book is insane
Reviewed in the United States on August 12, 2020
Verified Purchase
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.

Read more

7 people found this helpful

Helpful

Report
Yaya
A gentle introduction to dependent types
Reviewed in the United States on September 28, 2018
Verified Purchase
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.

Read more

29 people found this helpful

Helpful

Report
Vanessa
Amazing
Reviewed in the United States on November 24, 2018
Verified Purchase
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.

Read more

10 people found this helpful

Helpful

Report
Invisigoth
Beginner oriented
Reviewed in the United States on October 18, 2018
Verified Purchase
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.

Read more

10 people found this helpful

Helpful

Report
Charles Fout
The information is hidden in the conversation
Reviewed in the United States on April 19, 2024
Verified Purchase
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.

Read more

3 people found this helpful

Helpful

Report

Top reviews from other countries

Marcus
Superb intro to type theory but avoid the Kindle version
Reviewed in the United Kingdom on August 10, 2024
Verified Purchase

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.

Read more
Report
Schnackenpfefferhausen
Gentle at first, demanding towards the end
Reviewed in Germany on June 25, 2019
Verified Purchase
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.

Read more
Report
Em
quality
Reviewed in Australia on November 27, 2018
Verified Purchase
Great.

Read more
Report
Chris Ford
Learn what types are made of
Reviewed in the United Kingdom on November 11, 2018
Verified Purchase
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.

Read more
Report
avidreader
Quirky book....
Reviewed in the United Kingdom on December 19, 2018
Verified Purchase
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.

Read more

One person found this helpful
Report

See more reviews

Amazon Prime Free Trial

Sorry, there was a problem.

Sorry, there was a problem.

Follow the authors

The Little Typer (Mit Press) Illustrated Edition

Purchase options and add-ons

Frequently bought together

Products related to this item

Customer reviews

Review this product

Customers say

Images in this review

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Top reviews from other countries

5.0 out of 5 stars Superb intro to type theory but avoid the Kindle version

5.0 out of 5 stars Gentle at first, demanding towards the end

5.0 out of 5 stars quality

5.0 out of 5 stars Learn what types are made of

1.0 out of 5 stars Quirky book....

Superb intro to type theory but avoid the Kindle version

Gentle at first, demanding towards the end

quality

Learn what types are made of

Quirky book....