Structure And Interpretation Of Computer Programs``Have you read your SICP today?''. Also known as Si. Cp (pronounced . The second edition of the book uses a more modern version of Scheme. Review II The Structure and Interpretation of Computer Programs Course Summary This course is based on CS 61A The Structure and Interpretation of Computer Programs, Spring 2008. Structure and Interpretation of Computer Programs pdf download. Authors: Hal Abelson & Gerald Jay Sussman, Edition. CS61A: Structure and Interpretation of Computer Programs, Summer 2000 This page collectes my material from instructing the lower-division programming languages course at UC Berkeley. Language where the false value is #f, the empty list is (), and the symbol nil is a normal symbol, like any other, without any default binding or special meaning. The embedded interpreter has a few features in- progress including auto- grading and hints about correcting code that fails to evaluate. Because it is so extremely abstract, most readers would perceive a disconnect between it and the everyday act of programming - even in Scheme. It is a demanding book that its intended audience - first year CS students - rarely are prepared for. I've noticed that the positive reviews (like those of most challenging literature, such as James. Joyce) come primarily from those who studied the text on their own, while most of the negative reviews come from those who either taught or were taught with it. The book is intended to be a primer for novice students on advanced academic or engineering career tracks, aimed at teaching the basic theory of computer science. However, in the modern world of ubiquitous desktop computers with flashy graphical interfaces, most students have at least a year of experience in more conventional languages, and often have been programming since their early teens; they are usually familiar with very elaborate and powerful development environments which automate much of the programming process. Most have a very Language. Centric or even Ide.
Find helpful customer reviews and review ratings for Structure and Interpretation of Computer Programs (PUL) at Amazon.com. Read honest and unbiased product reviews from our users./>. Structure and Interpretation of Computer Programs (PUL) Centric? They are often immediately frustrated with the extremely minimal subset language used (and in case such as MIT Scheme, the equally minimalist programming environment), even if the purpose of covering the material from first principles is explained. The tasks given in the book seems simplistic and pointless to many, while at the same time often require a deeper understanding than they have needed in the past to get by. They expect to be able to immediately jump into advanced tasks such as game design without having to worry about the details - those are what libraries are for, after all - and cannot see the point of 'wasting time' understanding these fundamentals, especially when presented in a language which is so alien and whose idioms are in direct contradiction to those they aready are familiar with. Finally, most students of programming are looking for practical knowledge, and are used to getting it without much fanfare; the heavily theoretical nature of the book is off- putting to them. However, it also requires a professor who can bridge the gap between theory and practice, and show how this very mannered and pedantic material relates to more conventional programming. The text does not live on it's own; the teacher must breathe life into it. One must first learn how to learn, and walking into a classroom with notions about how things should be, is the student's fault, not the book's. While it is not a flaw in the book itself, it would be wise if the authors made some effort to address the issue in later editions. Whether this could be done without losing the essence of the original text is an open question. It is the introductory CS textbook at MIT, and it is probably too fast- paced to be a good book for most introductory courses, but it is an excellent book for CS graduate students to read to get ready for Ph. D qualifying exams! It made me think of computer programs on a higher plane. The defining moment was their crystallization of the central aspect of computer programming. The interpreter, which interprets and runs computer programs, is just another computer program. I found this fascinating. Fortunately, I no longer use C++ at work, I now use Common. Lisp, and try to apply the principles therein daily. It will teach you more about the essence of programming than any other book I know. In particular, I recommend going to Amazon and reading the reviews there. There are many very positive reviews like those given here, but there are also are some fascinating *highly* negative reviews from some sad folks who just . No wonder most serious programmers teach themselves. It is rather dense and therefore is not something you can just breeze through, but the material covered really made me think about programming from a completely different angle. It was also my first introduction to any LISP dialect, but don't let that hold you back. It gives you enough introductory material to be able to follow the discussion. I expect I'll still be recommending it when I retire, which won't be soon. It is not an easy book, but it is a great book. Learning prolog, smalltalk, forth and sml later taught me some other ways of thinking, but unfortunately no books in those languages carry the same spirit as sicp. Thinking. Forth is nice, but somehow not as deep. Perhaps someone can write a book called . What do you think is the minimum set of language features you would need to complete the exercises and come up with analogues for (or bypass) example code and concepts in the book? You will need to understand Scheme to read the examples. The specific language functions involved, IIRC, are define, lambda, let/letrec (and closures), arithmetic functions, if, car/cdr/cons, set!/set- car!/set- cdr!, and at the very end, the vector functions. But the book teaches Scheme as it goes along - or rather, it introduces you gently to Scheme, and you'll pick up the details as you go along. Scheme's a tiny language, and unlike CL, functions are very well named. So as long as you don't get thrown into the deep end of lambdas and call/cc (and SICP doesn't do that; lambdas are introduced gently, I don't think it mentions call/cc at all), you can learn it just by reading. Of course it mentions call/cc, for example, in the section about the Amb. Special. Form (see later). Most of the book is about building up higher and higher level abstractions from these primitives. So it does discuss map/fold/filter, but it explains how you get this from recursion on lists. There's a section on non- deterministic computing, but instead of just throwing amb, fail, and call/cc at you, it first explains the concept of a . It's easier to follow their explication from the beginning and not worry about how it compares to imperative or OO languages. So far, I've noticed the distinction between recursive and iterative processes is brought out into the language syntax, and binding isn't an issue since parameters are unnamed. In order to avoid any system- dependent material of even the most trivial sort, it intentionally does not discuss console or disk I/O (except for a passing uses of the (display) and (error) functions), loading external source code, macros, and the like. It also avoids many standard features of Scheme which were deemed unnecessary for their purposes - the (do) iterator, vectors, characters, strings (except, again for a few passing uses with no explanation). Much of the book is spent re- implementing features that are part of the core language (e. While this is admirable, and very valuable, it can also be quite dry and puzzling to a novice, and gives the incorrect impression that Scheme is a hopelessly crippled language where you must ceaselessly reinvent the wheel to do even trivial tasks. It can be particularly frustrating to students who are familiar with more conventional texts which emphasize immediate practical results rather than first principles. For this reason, it is often suggested that SICP be taught either after, or together with, a text on Scheme. Language such as Simply. Scheme or How. To. Design. Programs. You gain most by reading beside the computer with a Scheme interpreter and running the examples and exercises. Now I'm writing an interpreter, and remembered that SICP had some chapters about that. I found their description of an interpreter brilliant, at exactly the right level of abstraction, both code- wise and text- wise. I am tempted to say that the people who don't like it are the ones who just don't get it. While there is always some portion of people who can't or won't learn in some style or who really weren't interested, it's still rather a germane criticism of an educational book to say that one doesn't . I personally thought the book all right, but . No- one gets excited by implementing rationals, but plotting a mandelbrot at least makes pretty pictures. You will save us all a lot of trouble if you study this book carefully before you start your next design. Each section brings at least one unsettling insight, that throws new light on my prejudices about programming. The pacing of exercises is gentle, with the occasional nasty surprise thrown in to ward off complacency. How about a few people who've finished this share some of what those insights were rather than just teasing us? Among the topics: The way in which the use of state in programs is tied up with time in the real world; the advantages and disadvantages of using state; the concept of using streams as an alternate to local state variables; the problems this runs into when you introduce concurrency. This whole discussion in the book (sections 3. I'm thinking of in particular) is full of important ideas. While I think it misses a 4th category (means of restriction, like scoping rules, Static. Typing, or private/protected/public), it's a very useful way to think about programming and language design. I also thought the environment model of computation was wonderfully clear. I had a tough time understanding Lexical. Closures before that, because the concept mixes static and dynamic structure. The environment model made it wonderfully clear.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. Archives
April 2017
Categories |