counter create hit Concepts, Techniques, and Models of Computer Programming - Download Free eBook
Ads Banner
Hot Best Seller

Concepts, Techniques, and Models of Computer Programming

Availability: Ready to download

This innovative text presents computer programming as a unified discipline in a way that is both practical and scientifically sound. The book focuses on techniques of lasting value and explains them precisely in terms of a simple abstract machine. The book presents all major programming paradigms in a uniform framework that shows their deep relationships and how and where This innovative text presents computer programming as a unified discipline in a way that is both practical and scientifically sound. The book focuses on techniques of lasting value and explains them precisely in terms of a simple abstract machine. The book presents all major programming paradigms in a uniform framework that shows their deep relationships and how and where to use them together. After an introduction to programming concepts, the book presents both well-known and lesser-known computation models ("programming paradigms"). Each model has its own set of techniques and each is included on the basis of its usefulness in practice. The general models include declarative programming, declarative concurrency, message-passing concurrency, explicit state, object-oriented programming, shared-state concurrency, and relational programming. Specialized models include graphical user interface programming, distributed programming, and constraint programming. Each model is based on its kernel language—a simple core language that consists of a small number of programmer- significant elements. The kernel languages are introduced progressively, adding concepts one by one, thus showing the deep relationships between different models. The kernel languages are defined precisely in terms of a simple abstract machine. Because a wide variety of languages and programming paradigms can be modeled by a small set of closely related kernel languages, this approach allows programmer and student to grasp the underlying unity of programming. The book has many program fragments and exercises, all of which can be run on the Mozart Programming System, an Open Source software package that features an interactive incremental development environment.


Compare
Ads Banner

This innovative text presents computer programming as a unified discipline in a way that is both practical and scientifically sound. The book focuses on techniques of lasting value and explains them precisely in terms of a simple abstract machine. The book presents all major programming paradigms in a uniform framework that shows their deep relationships and how and where This innovative text presents computer programming as a unified discipline in a way that is both practical and scientifically sound. The book focuses on techniques of lasting value and explains them precisely in terms of a simple abstract machine. The book presents all major programming paradigms in a uniform framework that shows their deep relationships and how and where to use them together. After an introduction to programming concepts, the book presents both well-known and lesser-known computation models ("programming paradigms"). Each model has its own set of techniques and each is included on the basis of its usefulness in practice. The general models include declarative programming, declarative concurrency, message-passing concurrency, explicit state, object-oriented programming, shared-state concurrency, and relational programming. Specialized models include graphical user interface programming, distributed programming, and constraint programming. Each model is based on its kernel language—a simple core language that consists of a small number of programmer- significant elements. The kernel languages are introduced progressively, adding concepts one by one, thus showing the deep relationships between different models. The kernel languages are defined precisely in terms of a simple abstract machine. Because a wide variety of languages and programming paradigms can be modeled by a small set of closely related kernel languages, this approach allows programmer and student to grasp the underlying unity of programming. The book has many program fragments and exercises, all of which can be run on the Mozart Programming System, an Open Source software package that features an interactive incremental development environment.

30 review for Concepts, Techniques, and Models of Computer Programming

  1. 4 out of 5

    Arek Holko

    I'd read and completed most of the exercises from the Structure and Interpretation of Computer Programs (SICP) a couple of months ago. Then I've stumbled on reviews saying that this book is a logical next step in learning the programming language theory. I don't agree with them. It really doesn't add that much. Many topics and examples are just reiterations of those from SICP. Chapters concerning concurrent programming are well worth reading, but because of the choice of the language (and its ker I'd read and completed most of the exercises from the Structure and Interpretation of Computer Programs (SICP) a couple of months ago. Then I've stumbled on reviews saying that this book is a logical next step in learning the programming language theory. I don't agree with them. It really doesn't add that much. Many topics and examples are just reiterations of those from SICP. Chapters concerning concurrent programming are well worth reading, but because of the choice of the language (and its kernel implementation) it's hard to just jump into them. If you're coming from SICP I'd rather recommend reading books on dataflow concurrency and concurrent programming with threads and message passing. In my opinion CTM is an alternative to, but not a continuation of SICP. If you're still wondering whether this book is worth reading there's a nice summary of its content on authors page: http://www.info.ucl.ac.be/~pvr/VanRoy...

  2. 4 out of 5

    Xavier Shay

    Took a while, but I finally finished this. Plenty of good concepts in here, starting with dataflow variables (I didn't know the concepts) and building all the way up to distributed systems. Quite incredible to see pretty much all the computation models built up from the ground up with the bare minimum of parts. Breathtaking tribute to how simple programming can be. It's a textbook, and trying to read it as a book rather than as reference for a semester is pretty dense going. In particular I found Took a while, but I finally finished this. Plenty of good concepts in here, starting with dataflow variables (I didn't know the concepts) and building all the way up to distributed systems. Quite incredible to see pretty much all the computation models built up from the ground up with the bare minimum of parts. Breathtaking tribute to how simple programming can be. It's a textbook, and trying to read it as a book rather than as reference for a semester is pretty dense going. In particular I found the formal definitions not particularly enlightening nor informative for the practicality of programming.

  3. 5 out of 5

    Quinn

    Best programming book I ever read! It gets to the heart of the technology, favoring no one language over another. Comprehensive and should be required reading. Explains what object oriented programming is really about and illuminates it's limitations. First three chapters were a god send. Always found something new each time I re-read it. It's like the gift that keeps on giving. Also, it's free online.

  4. 4 out of 5

    Nick Black

    whoa, I never moved this to "read", interesting. i went back through a majority of it this Sunday night, writing an outline for PLT...the writing is exceptional, the kind where you immediately realize this will be a textbook a class above the main. excellent bibliography, rich in historical notes, lots of connections. by far the best material on declarative programming outside of Shapiro+Sterling's The Art of Prolog. i deduct one star because their mozart/oz system reminded me overmuch of squeak whoa, I never moved this to "read", interesting. i went back through a majority of it this Sunday night, writing an outline for PLT...the writing is exceptional, the kind where you immediately realize this will be a textbook a class above the main. excellent bibliography, rich in historical notes, lots of connections. by far the best material on declarative programming outside of Shapiro+Sterling's The Art of Prolog. i deduct one star because their mozart/oz system reminded me overmuch of squeak/smalltalk, and thus gave recurring offense. regardless, a new bar has been set regarding programming language design from a rather more applied perspective than is usually the case. together with pierce's Types and Programming Languages (and additionally barendregt's The Lambda Calculus for those born- or reborn-hardcore), this provides a fine graduate semester class on programming language theory and formal semantics. ---- Amazon 2009-04-11.

  5. 4 out of 5

    Colin Jones

    Takeaways: (1) dataflow variables (kind of like futures you can wait on even if they've not been defined) make reasoning about concurrency much easier. (2) reasoning about distributed state is possible, but wow. (3) constraint programming is beautiful, and perhaps a bit magical. (4) more available paradigms in a given language seems like a massive, massive win.

  6. 4 out of 5

    Gustavo Bicalho

    Mind blowing in diversity and depth of ideas. For me, it was a great introduction to dataflow programming, and the relational and constraint models.

  7. 4 out of 5

    Nikolai Volsky

    An ABSLOUTE must-read for all software engineers and programmers and especially so if you work with object-oriented or functional programming language.

  8. 5 out of 5

    Keegan

    I thought this book would be the holy grail. It is, in a lot of ways. It's an extraordinary book that paves the way for how programming aught to be taught. It's pragmatic in the sense that it teaches effective problem solving, gradually introducing new ways to accomplish programming tasks. Unlike most intro programming books that only teach within the object-oriented paradigm, CTM teaches OOP as just one way of many. There's a heavy focus on declarative programming and concurrency, and even if yo I thought this book would be the holy grail. It is, in a lot of ways. It's an extraordinary book that paves the way for how programming aught to be taught. It's pragmatic in the sense that it teaches effective problem solving, gradually introducing new ways to accomplish programming tasks. Unlike most intro programming books that only teach within the object-oriented paradigm, CTM teaches OOP as just one way of many. There's a heavy focus on declarative programming and concurrency, and even if you only use popular languages, you'll be able to apply the techniques learned to whatever you're working on. Additionally, and unlike similar books like the venerable "Structure and Interpretation of Computer Programs," CTM covers the formal underlying semantic model of the Oz programming language, which helps to demystify programming language theory and allows for a more thorough understanding of how your code is translated by the compiler. My gripes: The Oz language is not elegant in appearance. It is verbose and clunky. This appears to be intentional so as to avoid obfuscation of intent. However, after being introduced to more elegant declarative/functional languages such as Haskell and Scheme, I felt pained to work with a language like Oz. It may seem silly, but the feeling you get while using a language is very important. Also, the Oz programming environment does not feel mature. It's made to work best in Emacs, which is fine with me, but I had a hard time finding documentation for things like the compiler, and the book doesn't help much with this. The general advice seems to be to "go to the mailing list," but this seems like a bad excuse. In any case, this book is well worth the money, and I have gone back to it many times. It's the closest we'll get to a modern programming bible.

  9. 5 out of 5

    Titouan

    Interesting read, nice introduction

  10. 4 out of 5

    Hesiyun

    Learn a lot about computational models. Ideas about the models last, not for framework though.

  11. 4 out of 5

    Minh Nhật

    đọc 900tr cũng nản thật, may lão cũng làm 1 course trên edx nên mệt quá vào coi vid cũng đỡ :'< đọc 900tr cũng nản thật, may lão cũng làm 1 course trên edx nên mệt quá vào coi vid cũng đỡ :'<

  12. 4 out of 5

    Sonny Ny

    http://news.ycombinator.com/item?id=5... http://www.ulb.ac.be/di/rwuyts/INFO02... http://news.ycombinator.com/item?id=5... http://www.ulb.ac.be/di/rwuyts/INFO02...

  13. 5 out of 5

    Joe

    Everything you wanted to know about programming language paradigms. Forms a strong basis to being a true language-agnostic polyglot developer.

  14. 4 out of 5

    Larry Staton jr.

    One of those books that you need to read several times to really understand. I've read it once so far, but I loved it.

  15. 5 out of 5

    Joe Dumoulin

  16. 4 out of 5

    Jonathan

  17. 4 out of 5

    Mark

  18. 5 out of 5

    Brian

  19. 4 out of 5

    Margaret Mullins

  20. 4 out of 5

    Hugo Alexander

  21. 5 out of 5

    Kristen

  22. 5 out of 5

    Serge

  23. 4 out of 5

    Ramzifu

  24. 5 out of 5

    Gaurav

  25. 5 out of 5

    Elron

  26. 5 out of 5

    Andy Legkiy

  27. 4 out of 5

    Santanu Hazra

  28. 5 out of 5

    Bernard Schmitz

  29. 5 out of 5

    banjiewen

  30. 5 out of 5

    Hitendra Solanki

Add a review

Your email address will not be published. Required fields are marked *

Loading...
We use cookies to give you the best online experience. By using our website you agree to our use of cookies in accordance with our cookie policy.