--- product_id: 25082988 title: "Design Concepts in Programming Languages" price: "₹ 10421" currency: INR in_stock: true reviews_count: 6 url: https://www.desertcart.in/products/25082988-design-concepts-in-programming-languages store_origin: IN region: India --- # Design Concepts in Programming Languages **Price:** ₹ 10421 **Availability:** ✅ In Stock ## Quick Answers - **What is this?** Design Concepts in Programming Languages - **How much does it cost?** ₹ 10421 with free shipping - **Is it available?** Yes, in stock and ready to ship - **Where can I buy it?** [www.desertcart.in](https://www.desertcart.in/products/25082988-design-concepts-in-programming-languages) ## Best For - Customers looking for quality international products ## Why This Product - Free international shipping included - Worldwide delivery with tracking - 15-day hassle-free returns ## Description Design Concepts in Programming Languages: 9780262201759: Computer Science Books @ desertcart.com Review: Excellent Book in Excellent Condition - It's exactly what was advertised. This is the best and most comprehensive entry-level text on PL semantics. Review: An outstanding treatment of programming language theory - The book is about various concepts encountered in various kinds of programming languages: denotational and operational (BOS/SOS) semantics, issues of state and control, type systems, modules, modeling effects and compilation. Every concept is introduced by defining the semantics of a language that has this concept and exploring the design dimensions and issues of this concept and language. Concepts are gradually accumulated, and by the time you reach the chapter on modules you've got a CBV language with records, mutable state, polymorphic algebraic data types, a System F type system with type inference and a hint of dependent types, abstract data types and first-class dynamically loadable modules. The tools used for description are of course the good old denotational and operational semantics and typing judgements and derivation trees; but each element of those is clearly and succintly described in text; it happens to me all the time that I am reading a type reconstruction algorithm and wondering, "why does this rule have that restriction?" and it immediately turns out that in the next paragraph, the authors focus attention on why this rule has that restriction; just like if they were reading my thoughts. That's why this book feels very comfortable to me: I am absolutely sure that I won't encounter a point where I am lost and buried under the notation; but there is also not a single boring moment. I've been interested in functional programming and PL theory for 2-3 years already, and here's a brief list of the *new* things that I have learned, at least: - What do SOS and BOS mean, and why one should care, and what properties a SOS might posess (confluence and normalization, for instance) - How many features of languages can be defined in terms of simply desugaring, and how in some cases they can't - How one might use monadic style in the semantics metalanguage to greatly simplify the semantic rules for monadic concepts like state, control and error handling (the authors mention the word "monad" only once, but they use return- and bind-like operators in their semantics) - How powerful records are, and of what use are operators like "conceal" - What use is subtyping outside of OOP - How does one define CPS-style semantics and how such a style allows to add state, control and errors with minimal changes - How small yet powerful an OOP language core can be - How algebraic datatypes can be very useful even in a language without static typing - How pattern matching can be desugared into CPS-style deconstructors - How many caveats are there in defining typing rules, and how a small change in them can lead to very big changes in language expressiveness - How HM type inference actually works - Why purity is important for certain polymorphism issues - What let-polymorphism means - What effect systems are - How effect reconstruction works and how it is different from type reconstruction in nature - How effect inference can prove the external purity of certain internally impure programs That's where I finished my reading for now. The remaining looks even more intriguing; for example, I don't (yet) know how functional languages are compiled and how register allocation is done. I'm afraid to sound like a salesman, but this is absolutely the best-written technical book I have ever seen in my life, and probably the most influential one for me, excluding maybe SICP. ## Technical Specifications | Specification | Value | |---------------|-------| | Best Sellers Rank | #3,276,022 in Books ( See Top 100 in Books ) #3,586 in Computer Programming Languages #8,329 in Programming Languages (Books) | | Customer Reviews | 4.8 4.8 out of 5 stars (10) | | Dimensions | 8.25 x 2.25 x 9.25 inches | | ISBN-10 | 0262201755 | | ISBN-13 | 978-0262201759 | | Item Weight | 5.2 pounds | | Language | English | | Print length | 1322 pages | | Publication date | January 1, 2008 | | Publisher | Mit Pr | ## Images ![Design Concepts in Programming Languages - Image 1](https://m.media-amazon.com/images/I/41AFPRTGNQL.jpg) ## Customer Reviews ### ⭐⭐⭐⭐⭐ Excellent Book in Excellent Condition *by A***S on February 11, 2026* It's exactly what was advertised. This is the best and most comprehensive entry-level text on PL semantics. ### ⭐⭐⭐⭐⭐ An outstanding treatment of programming language theory *by E***E on March 22, 2009* The book is about various concepts encountered in various kinds of programming languages: denotational and operational (BOS/SOS) semantics, issues of state and control, type systems, modules, modeling effects and compilation. Every concept is introduced by defining the semantics of a language that has this concept and exploring the design dimensions and issues of this concept and language. Concepts are gradually accumulated, and by the time you reach the chapter on modules you've got a CBV language with records, mutable state, polymorphic algebraic data types, a System F type system with type inference and a hint of dependent types, abstract data types and first-class dynamically loadable modules. The tools used for description are of course the good old denotational and operational semantics and typing judgements and derivation trees; but each element of those is clearly and succintly described in text; it happens to me all the time that I am reading a type reconstruction algorithm and wondering, "why does this rule have that restriction?" and it immediately turns out that in the next paragraph, the authors focus attention on why this rule has that restriction; just like if they were reading my thoughts. That's why this book feels very comfortable to me: I am absolutely sure that I won't encounter a point where I am lost and buried under the notation; but there is also not a single boring moment. I've been interested in functional programming and PL theory for 2-3 years already, and here's a brief list of the *new* things that I have learned, at least: - What do SOS and BOS mean, and why one should care, and what properties a SOS might posess (confluence and normalization, for instance) - How many features of languages can be defined in terms of simply desugaring, and how in some cases they can't - How one might use monadic style in the semantics metalanguage to greatly simplify the semantic rules for monadic concepts like state, control and error handling (the authors mention the word "monad" only once, but they use return- and bind-like operators in their semantics) - How powerful records are, and of what use are operators like "conceal" - What use is subtyping outside of OOP - How does one define CPS-style semantics and how such a style allows to add state, control and errors with minimal changes - How small yet powerful an OOP language core can be - How algebraic datatypes can be very useful even in a language without static typing - How pattern matching can be desugared into CPS-style deconstructors - How many caveats are there in defining typing rules, and how a small change in them can lead to very big changes in language expressiveness - How HM type inference actually works - Why purity is important for certain polymorphism issues - What let-polymorphism means - What effect systems are - How effect reconstruction works and how it is different from type reconstruction in nature - How effect inference can prove the external purity of certain internally impure programs That's where I finished my reading for now. The remaining looks even more intriguing; for example, I don't (yet) know how functional languages are compiled and how register allocation is done. I'm afraid to sound like a salesman, but this is absolutely the best-written technical book I have ever seen in my life, and probably the most influential one for me, excluding maybe SICP. ### ⭐⭐⭐⭐⭐ Good *by Z***B on December 8, 2023* Good --- ## Why Shop on Desertcart? - 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016 - 🌍 **Shop Globally** — Access 737+ million products across 21 categories - 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price - 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members) - 🔒 **Secure Payments** — Trusted payment options with buyer protection - ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews **Shop now:** [https://www.desertcart.in/products/25082988-design-concepts-in-programming-languages](https://www.desertcart.in/products/25082988-design-concepts-in-programming-languages) --- *Product available on Desertcart India* *Store origin: IN* *Last updated: 2026-05-19*