Programming Language Pragmatics
by Michael L. Scott
Average Customer Review:
Hardcover (15 January, 2000)
list price: $74.95 -- our price: $74.95
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

As a textbook suitable for the classroom or self-study, Michael Scott's Programming Language Pragmatics provides a worthy tour of the theory and practice of how programming languages are run on today's computers. Clearly organized and filled with a wide-ranging perspective on over 40 different languages, this book will be appreciated for its depth and breadth of coverage on an essential topic in computer science.

With references to dozens of programming languages, from Ada to Turing and everything in between (including C, C++, Java, and Perl), this book is a truly in-depth guide to how code is compiled (or interpreted) and executed on computer hardware. Early chapters tend to be slightly more theoretical (with coverage of regular expressions and context-free grammars) and will be most valuable to the computer science student, but much of this book is accessible to anyone seeking to widen their knowledge (especially since recent standards surrounding XML make use of some of the same vocabulary presented here).

The book has a comprehensive discussion of compilation and linking, as well as how data types are implemented in memory. Sections on functional and logical programming (illustrated with Scheme and Prolog, which are often used in AI research) can expand your understanding of how programming languages work. Final sections on the advantages--and complexities--of concurrent processing, plus a nice treatment of code optimization techniques, round out the text here. Each chapter provides numerous exercises, so you can try out the ideas on your own.

Students will benefit from the practical examples here, drawn from a wide range of languages. If you are a self-taught developer, the very approachable tutorial can give you perspective on the formal definitions of many computer languages, which can help you master new ones more effectively. --Richard Dragan

Topics covered: A survey of today's programming languages, compilation vs. interpretation, the compilation process, regular expression and context-free grammars, scanners and parsers, names, scopes and bindings, scope rules, overloading, semantic analysis, introduction to computer architecture, representing data, instruction sets, 680x0 and MIPs architectures, control flow and expression evaluation, iteration and recursion, data types, type checking, records, arrays, strings, sets, pointers, lists, file I/O, subroutines, calling sequences and parameter passing, exception handling, coroutines, compile back-end processing, code generation, linking, object-oriented programming basics, encapsulation and inheritance, late binding, multiple inheritance, functional and logical languages, Scheme and Prolog, programming with concurrency, shared memory and message passing, and code optimization techniques. ... Read more

Reviews (12)

Not just for compiler developers. A little too much RISC
I agree that every compiler writer (not engineer: programming is a cruelly difficult writing *sui generis*, not engineering) needs this book but its market is or should be much wider.

There is NO way to learn programming except at the intersection between compiler writing and applications programming, and it is a MISTAKE to teach programming as either a context-free application programmer's worship of machines and authority, or as the acquaintance with one programming language, its mistakes of design and implementation included, as Eleusinian mysteries demanding reverence.

Dijkstra, famously, described programming as applied mathematics. The concept of "applied" introduces an ineradicable tension between one discipline and another where the key ability is the ability to shuttle between layers of representation.

Crude language speaks airily of the needs of the user, where the user is hypostatized, singular, male, and imaged as wealthy and lacking taste. The actuality is that the relationship goes in computing all the way down, one user is also a worker for another, and only a programmer who has mastered his trade understands the need to transcend, in the course of understanding, the relationship.

Thus this book is useful not only to the compiler writer but also to the application programmer, because (for example), the application programmer has to understand at least in general terms how the For or Do construct of his language is evaluated.

He's importuned instead to meditate upon business needs with the result that something like 80% of large systems fail.

A programmer who, in Visual Basic, does not understand that For intIndex1 = 1 To intLimit - 1 is not "inefficient" because the expression is evaluated by value, doesn't know his trade. A programmer who, in C, doesn't know that while ( intIndex1 = 0; intIndex <= intLimit - 1; intIndex++ ) IS inefficient insofar as the expression is repeatedly evaluated doesn't know his trade, and the book is full of useful information about these important semantic issues.

Many programmers use the totally inappropriate automobile metaphor to describe the computer and in so doing they declare that no more than they would look under the hood of their car, they should be freed of important issues of semantics and if possible coherent and readable syntax in their mindless coding.

The metaphor confuses a force and energy determined system with an information engine. It also encapsulates a narrow understanding, restricted to America and other energy-wasteful societies, of what it means to relate, even to cars, for the atypical but thrifty American, who buys manual transmission used cars, or the Havana teen, who starts his car by rolling it down the hill, both are familiar, of necessity, with what goes on "under the hood"...or else.

A person with claims to professional writing skills would of course be familiar with semantics as well as syntax. But in programming, semantics is confused with "being a compiler developer or something".

Unlike natural language semantics, which bleeds out in history and sociology, programming language semantics is coeval with the "way the compiler works" in the sense of its specification, captured NOT in Programming Languages for Dummies BUT INSTEAD in the specifications document for the language.

[In France titles in the For Dummies series are "pour les nuls", which is *tres amusant*. I don't mean to slam this series which is well written and useful, but its title needs rethinking, for it at once asserts class pride and solidarity while disempowering in the very act of doing so.]

Good program design is based on knowing how the compiler "works" in the sense of understanding the language contract, which in C forces while evaluation by reference but in Visual Basic forces it by value.

The advanced material in this book on the implementation of Prolog and logic languages is important because it shows how far these languages are from being complete in the sense of first-order logic with quantification, which explains the survival of procedural languages.

My First Computer Book, special-ordered from the Roosevelt University Bookstore in 1971, was Peter Wegner's Information Structures, Programming Languages, and Machine Organization, a book in the Algol tradition which taught how to think at the Edge City, where the user's problem meets the circuits. This book, like Wegner, teaches the same lessons. About its only flaw is that like many titles from Morgan Kaufmann, which seems to have an incestuous relationship with MIPS and the RISC kiddies, it overemphasizes clever optimization and completely downplays the importance of the stack model of computation, a RISCy tradition.

Required for every Compiler Engineer
This is must read for every compiler engineer.

This book is 800+ pages of theory behind language design and processing of languages.

Altought it is very theoretical, it's very easy to read and well written and a pleasure to read. There are a lot of examples/figures/tables etc to explain things. I recommend people which are totally new to language design/compiler design to first read an introduction text. I can really recommend 'programming language processors in java' from Watt and Brown. This is a really good book.

The title of the book suggest that this book will only cover Language Design. In reality chapter 2, 3,4 and 5 covers in depth resp. Syntax checking (parsing), Names/Scope/Binding, Semantic Analysisand processor architecture.

Beside in depth analysis of language design (e.g. OO-, functional-, imperative- and logical-languages) it gives some practical implementation advice/tips. E.g. there are only a few compilerbooks which seriously talks about the different parsing error recovery techniques. This book explain some different recovery methods. Probably error recovery is not scientific enough for the other books, but for a compiler user error recovery is really important.

A last tip: this book comes in 2 editions: a paperback and hardcover edition. If you want to save some money buy the paperback.

The best book to learn computer language fundamentals
Scott is a marvelous teacher. The book covers everything from language syntax to functional programming with ease and depth. The study of programming languages though skipped by most programmers is an essential element if you want to be a better programmer.
The exercises given at the end of chapters are excellent and will reinforce your understanding. At a time when programming languages are proliferating at an amazing rate, it is essential you know how to compare the various aspects of different languages and choose the one most suitable for your work. Studying this will help you in that endeavour.
Get this book, but better read it. ... Read more

Isbn: 1558604421
Subjects:  1. Compilers    2. Computer Architecture - General    3. Computer Bks - Languages / Programming    4. Computer Books: Languages    5. Computers    6. Pragmatics    7. Programming - Software Development    8. Programming Language Semantics    9. Programming Languages - General    10. Programming languages (Electro    11. Programming languages (Electronic computers)    12. Computers / Programming / Software Development   

Structured Computer Organization (4th Edition)
by Andrew S. Tanenbaum
Average Customer Review:
Hardcover (23 October, 1998)
list price: $108.00 -- our price: $108.00
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Reviews (38)

Book is fine
Ignore the other reviewers comments who are lazy and/or incapable of doing the end-chapter problems, it's amusing how many people repeated that(like parrots).
Some problems take more time and require compact understanding of concepts explained so far and some are easy, I used the book for an independent study course and it's readable, presenting a good deal of material, and includes quite funny comments in the text. I recommend it.

Tanenbaum needs new publisher and editors
Andrew Tanenbaum might be the best there is when it comes to the study of computers but, unless you're a "thorough geek," you'd wish other technical writers would step into the fore.

Tanenbaum's books all use the same single technique to help students remember important ideas:bold letters.That's it.You'd be hard pressed to understand the main concepts most of the times because, like a forgetful professor, he'd sometimes mention it in passing (without bold font) that you think they weren't that important.Until one pops up in one of his chapter problems, then you're through.

He does not provide any solutions at the end of his books.One gets the sense he wrote his books for the instructors/professors who are too lazy (or uncreative) to come up with their own sample problems for the students.I wish they'd write computer science books the way mathematicians write their books: They assume their students are "mathematically-challenged" so they go that extra mile to make sure the students get the point.They provide answers to odd-number problems, for one.They also make sure the layout of their books are arranged so that students don't miss the main ideas.With Tanenbaum, you'd have to dig everywhere; you don't know whether to search in the current, previous, or the following chapters for help in answering the problems.

I still have a few more semesters of computer science; I'm almost sure all the textbooks would be written by Tanenbaum (again!).I dread the thought.

So, Tanenbaum, if you're reading this:Please, please, look for another publisher and editor who would help you in the layout of your book.And please, please, provide some answers to some of your problems for the students.At over a hundred bucks, I want my money's worth!

The Book
Does any one know of a solution mannual for this book? The questions at the end of the book are nice and all but they are really hard to solve. ... Read more

Isbn: 0130959901
Sales Rank: 105331
Subjects:  1. Computer Architecture    2. Computer Architecture - General    3. Computer Bks - General Information    4. Computer Books: General    5. Computer organization    6. Computer programming    7. Computers    8. Computers / Computer Architecture   

Operating System Concepts, 6th Edition
by AbrahamSilberschatz, Peter BaerGalvin, GregGagne, A Silberschatz
Average Customer Review:
Hardcover (26 June, 2001)
list price: $104.95
US | Canada | United Kingdom | Germany | France

Editorial Review

Operating systems are large and complex, and yet must functionwith near-absolute reliability--that's why they're a class untothemselves in the field of software development. Since its firstrelease 20 years ago, "the dinosaur book"--Operating SystemConcepts by Abraham Silberschatz, Peter Baer Galvin, and GregGagne--has been a valuable reference for designers and implementers ofoperating systems. The newly released sixth edition of this bookmaintains the volume's authority with new sections on threadmanagement, distributed processes, and the Java Virtual Machine (JVM).There's also information on the workings of the latest crop ofoperating systems, including Microsoft Windows 2000, Linux, FreeBSD,and compact operating systems for handheld devices.

This book isconcerned with the design of operating systems, which is to say itenumerates the problems that pop up in the creation of efficientsystems and explores alternative ways of dealing with them, detailingthe advantages and shortcomings of each. For example, in their chapteron scheduling CPU activity, the authors explain several algorithms(first-come, first-served, and round-robin scheduling, among others)for allocating the capacity of single and multiple processors amongjobs. They highlight the relative advantages of each, and explain howseveral real-life operating systems solve the problem. They thenpresent the reader with exercises (this book is essentially auniversity textbook) that inspire thought and discussion. --DavidWall

Topics covered: The problems faced by designers of systemsoftware for electronic computers, and strategies that have beendeveloped over the past 20 years to address (and, in some cases, solve)them. Problems of CPU scheduling, memory allocation, paging, processesand threads, storage management, distributed processes and storagemechanisms, and security are all discussed thoroughly and with manyauthoritative references. ... Read more

Reviews (54)

Accessible treatment of complex topics
This book does a great job of presenting all details of operating system design and operation. When appropriate, the authors point out how Linux, Solaris or Windows implements a given topic. This is valuable for software developers who work on these platform and need to understand how the scheduler is going to react if you spawn new threads/processes.

The one bad thing I can say is that some examples are too general and do not convey the proper detail. This is just a minor distraction and does not take away from the book's overall effectiveness.

Great Fundamentals of OS Book
Good book for learning OS principles for undergrad and lower grad students. I recommend this for hose wanting an introduction to OS Internals.

I prefer this to Modern OS by Tanenbaum.

Mediocre to poor OS book
It's been around 13 years since I took a course on OSes. I decided to purchase this book as a reference and to review some of the material that I have not had to deal with for a long time (e.g. synchronization primitives). I found the book to be a poor reference and found the chapters that I read to have poor or lacking exposition of the principles, data structures, and algorithms involved. e.g. there were sections where he lists pseudocode and says "see fig 2.13 for the algorithm" with no discussion of the reasoning behind the algorithm. The book also did not take any time to discuss practical considerations, e.g. implementing synchronization primitives with modern optimizing compilers and on modern out-of-order memory systems.

I am looking for a better substitute, and for now would suggest passing on this book. ... Read more

Isbn: 0471417432
Subjects:  1. Computer Bks - Operating Systems    2. Computer Books And Software    3. Computer Operating Systems    4. Computers    5. Operating Systems - General    6. Operating systems (Computers)    7. Programming - Systems Analysis & Design    8. Programming Languages - General    9. Computers / Operating Systems / General    10. Operating systems & graphical user interfaces (GUIs)   

Introduction to Algorithms, Second Edition
by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
Average Customer Review:
Hardcover (01 September, 2001)
list price: $80.00 -- our price: $80.00
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Aimed at any serious programmer or computer science student,the new second edition of Introduction to Algorithms builds onthe tradition of the original with a truly magisterial guide to theworld of algorithms. Clearly presented, mathematically rigorous, andyet approachable even for the math-averse, this title sets a highstandard for a textbook and reference to the best algorithms forsolving a wide range of computing problems.

With sample problems andmathematical proofs demonstrating the correctness of each algorithm,this book is ideal as a textbook for classroom study, but its reachdoesn't end there. The authors do a fine job of explaining eachalgorithm. (Reference sections on basic mathematical notation will helpreaders bridge the gap, but it will help to have some math backgroundto appreciate the full achievement of this handsome hardcover volume.)Every algorithm is presented in pseudo-code, which can be implementedin any computer language, including C/C++ and Java. This ecumenicalapproach is one of the book's strengths. When it comes to sorting andcommon data structures, from basic linked lists to trees (includingbinary trees, red-black, and B-trees), this title really shines, withclear diagrams that show algorithms in operation. Even if you justglance over the mathematical notation here, you can definitely benefitfrom this text in other ways.

The book moves forward with moreadvanced algorithms that implement strategies for solving morecomplicated problems (including dynamic programming techniques, greedyalgorithms, and amortized analysis). Algorithms for graphing problems(used in such real-world business problems as optimizing flightschedules or flow through pipelines) come next. In each case, theauthors provide the best from current research in each topic, alongwith sample solutions.

This text closes with a grab bag of usefulalgorithms including matrix operations and linear programming,evaluating polynomials, and the well-known Fast Fourier Transformation(FFT) (useful in signal processing and engineering). Final sections on"NP-complete" problems, like the well-known traveling salesman problem,show off that while not all problems have a demonstrably final and bestanswer, algorithms that generate acceptable approximate solutions canstill be used to generate useful, real-world answers.

Throughout thistext, the authors anchor their discussion of algorithms with currentexamples drawn from molecular biology (like the Human Genome Project),business, and engineering. Each section ends with short discussions ofrelated historical material, often discussing original research in eacharea of algorithms. On the whole, they argue successfully thatalgorithms are a "technology" just like hardware and software that canbe used to write better software that does more, with betterperformance. Along with classic books on algorithms (like DonaldKnuth's three-volume set, The Art of ComputerProgramming), this title sets a new standard for compiling thebest research in algorithms. For any experienced developer, regardlessof their chosen language, this text deserves a close look for extendingthe range and performance of real-world software. --RichardDragan

Topics covered: Overview of algorithms (including algorithms asa technology); designing and analyzing algorithms; asymptotic notation;recurrences and recursion; probabilistic analysis and randomizedalgorithms; heapsort algorithms; priority queues; quicksort algorithms;linear time sorting (including radix and bucket sort); medians andorder statistics (including minimum and maximum); introduction to datastructures (stacks, queues, linked lists, and rooted trees); hashtables (including hash functions); binary search trees; red-blacktrees; augmenting data structures for custom applications; dynamicprogramming explained (including assembly-line scheduling, matrix-chainmultiplication, and optimal binary search trees); greedy algorithms(including Huffman codes and task-scheduling problems); amortizedanalysis (the accounting and potential methods); advanced datastructures (including B-trees, binomial and Fibonacci heaps,representing disjoint sets in data structures); graph algorithms(representing graphs, minimum spanning trees, single-source shortestpaths, all-pairs shortest paths, and maximum flow algorithms); sortingnetworks; matrix operations; linear programming (standard and slackforms); polynomials and the Fast Fourier Transformation (FFT); numbertheoretic algorithms (including greatest common divisor, modulararithmetic, the Chinese remainder theorem, RSA public-key encryption,primality testing, integer factorization); string matching;computational geometry (including finding the convex hull);NP-completeness (including sample real-world NP-complete problems andtheir insolvability); approximation algorithms for NP-complete problems(including the traveling salesman problem); reference sections forsummations and other mathematical notation, sets, relations, functions,graphs and trees, as well as counting and probability backgrounder(plus geometric and binomial distributions). ... Read more

Reviews (122)

Too much coverage and few examples
I am a MS student, we used this book as Text Guide. Thank God I pass although I just got a B in part due to the poor coverage of exercises of this book. Despite of my willingness to try the examples and exercises it was really frustating not be able to check any of my answers.
First of all the book tries to cover all the possible topics related to Algorithms from sortingto NP-completeness problems. My recommendation, focus on what you know well and cover it thouroughly or at least split this book in 2 volumes.
Second, the anoying way to explain things by leaving them as exercises.
Third, the exercises were not in any way helpful to reinforce the material covered in the chapter, on the contrary are just the introduction of new concepts; and on top of that no answers available. In some cases the answers are not even related to the chapter you are reviewing, just an example, the solution for some of the problems in NP chapter are the application of Dynamic Programming which is a different chapter in the book.

If you have the unfortune of using this book, search on the net for answers that may guide you on your homework assignments.

Best of the luck.

Comprehensive and (almost) complete.
I am an EE PhD student in Princeton, with basic CS background. I bought this book about a week ago, and I just finished reading more than half of it. I am impressed by the organisation and dedication of the authors to write something understandable to a wide audience, without sacrificing in depth analysis. If you need a good and complete introductory book,that summarizes also the latest research in the field, I would recommend this one.

Drawbacks...Minor (+ I am a weird guy) and hardly mentionable, but I have the feeling that some proofs may have been presented more rigorously. I would also like to see more examples or SOLUTIONS to some of the problems.

Lots of stuff, but a little verbose
A good introductory text but that's about it. Any CS major worth his salt should chew his way through this level material pretty quickly, and there's the only rub... at points this could be a little bit more concise because it actually can aid understanding in an exact field. Sometimes less is more. The spared pages could be used to cover more material or to raise the bar a little. ... Read more

Isbn: 0262032937
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: Operating Systems    3. Computer Science    4. Computer algorithms    5. Computer programming    6. Computers    7. Programming - Algorithms    8. Computers / Computer Science   

Discrete Mathematics and its Applications
by Kenneth H. Rosen, Wcb, McGraw-Hill
Average Customer Review:
Hardcover (11 December, 1998)
list price: $149.10 -- our price: $149.10
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Reviews (69)

Just plain confusing...
This book is pretty useless when it comes to explaining concepts that it attempts to teach. It skips steps and fails to explain how to solve a lot of problems. I usually have to have a math tutor, or the teacher explain the lessons to me, because the 15-page sectionsin the book seem to get me nowhere. I wouldn't have a problem with discrete math if we had a different textbook.

Reasonably good text, very poor student/instructor guides.
The text itself is brief, but still a good overview of discrete mathematics.The main problem is the student and instructor guides.The answers frequently have errors and problems are not reiterated in the text, so a student or a grader has to flip back and forth between at least two books to make sense of the solutions.Even more frustrating for students is the fact that some problems do not have good answers: the author admits that he cannot solve the problem and refers to answers from other problems instead.This is simply not fair to students who may be struggling with the material.

As a teaching assistant, it is not up to me to select the text books.If it were, I would look for a replacement.

Horrid, Painful, and Savage
This is perhaps the worst book possible for a math class as difficult as this one.The examples assume you know a lot about Discrete Math so the author leaves out required information that you have to deduce. It should be titled "Discrete Math II: Buy The Book, Give Me Your Money, Foreward My Career." He has made mathematics painfully difficult.The solutions manual increases what the textbook has in the answer section by about 5%. All in all, it leaves you with more questions and more confusion. And then this jerk hits you with a ridiculously high price tag. This guy is a criminal, his bowls should be cut out and burned and then fed to him. ... Read more

Isbn: 0072899050
Sales Rank: 215149
Subjects:  1. Computer Science    2. Discrete Mathematics    3. Discrete Mathematics (Computer Science)    4. General    5. Mathematics    6. Mathematics (General)    7. Science/Mathematics    8. Applied mathematics   

Introduction to Automata Theory, Languages, and Computation (2nd Edition)
by John E. Hopcroft, Rajeev Motwani, Jeffrey D. Ullman
Average Customer Review:
Hardcover (14 November, 2000)
list price: $111.60 -- our price: $111.60
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

This book is a rigorous exposition of formal languages and models of computation, with an introduction to computational complexity. The authors present the theory in a concise and straightforward manner, with an eye out for the practical applications. Exercises at the end of each chapter, including some that have been solved, help readers confirm and enhance their understanding of the material. This book is appropriate for upper-level computer science undergraduates who are comfortable with mathematical arguments. ... Read more

Reviews (31)

Need some challenge? Come here!
I started to learn this course at the beginning of this semester and I just brought this book from Amazon in August.
I had no introductory course before but I was so curious about this subject so I am taking this graduate level course.
Now, I am in chapter 10, and I would like to give a review of this book.
This book is well organized, from the beginning to the end.
I have read almost each word in this book(including the extra ones in the box), and I would like to say: It is worth to do that.
Although sometimes the sentences are not very clear(maybe because I am an international student), but almost all the ideas are precious. So, please be patient when you are reading.
Trust me, if you do not have any related course before, you need time for it. but if you can understand all the contents in this book, and if you are more energetic, finishing most of the exercise with excalmatory marks, you will find your mind becomes so clear that is beyond your imagination.
For the tests, if there are some in your class, is only a half piece of cake. you will feel 100 points is just for the left hand(given the condition that you are a right-hander). :)
If you buy an international version, prepare to visit the book's website. and I will say this second edition seems to me the -1th edition because it contains all the errors listed on the website. Prepare you pen and become a co-auther of the book.
If you feel you need to improve your mathematics, take it, because reading this book can improve your mathematical thinking and proof ability tremendously.
If you feel all the course in your university is too easy and can not match your intelligence, take it, then you will find something interesting.

first edition is a classic, the second one unremarkable
The first edition is one of the best book in its field. A classic. A reference for many advanced courses in computer theory.

Sadly, the second edition misses a great deal of the first edition. Many chapters were removed. Important lemmas and theorems are missing.

I would gladly exchange my second edition for the first one, if it wasn't out of print.

J.

Excellent introductory text, but has several weaknesses
This was my textbook for an introductory course on Finite Automata and Languages - I enjoyed it a lot and I think that the chapters until the Turing Machines are covered very well, along with good examples. As one previous reviewer has already mentioned, the exercises can get very hard as compared to what's actually presented - this I found not too good.

The topics of complexity classes and NP-Completeness, as well as the chapter on Turing Machines are rather succint and do not cover the full depth. Papadimitriou's "Computational Complexity" does a better job in this respect, even though it is not at all flawless. Some might say that there is a reason why this book is introductory, but I argue that instead of doing a poor job, the authors should have maybe just made another book dealing with the above-mentioned topics.

PS: My professor told me that the first edition was much better - maybe you could find it somewhere in the library, if interested. ... Read more

Isbn: 0201441241
Subjects:  1. Computational complexity    2. Computer Science    3. Formal languages    4. Logic    5. Machine theory    6. Mathematics    7. Number Theory    8. Science/Mathematics    9. Computers / Computer Science   

Principles of Compiler Design (Addison-Wesley series in computer science and information processing)
by Alfred V. Aho, Jeffrey D. Ullman
Average Customer Review:
Hardcover (01 August, 1977)
list price: $42.45
US | Canada | United Kingdom | Germany | France

Reviews (5)

Good for starters
This book gives a good synopsis of each topic, but you'll have to look elsewhere for detail. For example, when discussing the parsing alogrithms of regular expressions, only a few strategies are mentioned.

Excellent book but not for a `crash course'
The top researchers in the field give this (by now) legendary compiler book. Crisp and stimulating discussions of the various phases of compilers. A major disadvantage is that examples & exercises are few. Whilereading the stuff on LALR parsers for the first time one feels woefullylost.... serious stuff intended for careful study - not just another bookfor perusal.

The Best Book Available on Compiler Design
The quintessential reference for anyone interested in the subject of compiler design and development. This sub-field of Computer Science forms a scientific core the theory of which is universally applicable to so manyareas of our field that every professional computer scientist and softwaredeveloper/programmer should be intimately familiar with the basic tenetsincluded: lexical analysis, parsing, optimization, symbol management, spacevs. time considerations, and especially BNF (notation for specifyinggrammars). Even if you are not a compiler developer and have no intentionof becoming one, this knowledge is so fundamental to being a good softwaredeveloper and intelligent user of compilers that no professional can affordnot to have read this book and keep it handy as a reference. ... Read more

Isbn: 0201000229
Sales Rank: 255225
Subjects:  1. Compilers (Computer programs)    2. Questions & Answers    3. Reference   

Algorithms (Teach Yourself)
by Anthony Ralston, Hugh Neill
Average Customer Review:
Paperback (01 August, 1997)
list price: $12.95
US | Canada | United Kingdom | Germany | France

Reviews (2)

Very old; refers to Pascal; uses obscure notation
I've taken only one course in programming (C++) and was hoping this bookwould provide me with a better understanding of algorithms.My biggestproblem with this book is that they use their own notation based on olderprogramming languages (such as Pascal) - I had a hard time moving from aC++ way of thinking to figuring out how they were expressing the samething.It didn't work for me because of this... This book looks as if itsover 25 years old and is very British.It has some odd Englishcolloquialisms and is written for an English audience.I really don'tthink - in an object-oriented world, I could recommend this book - if youtried to move to C++ from this, you'd be very confused.

Do you want to learn to write computer games?
You know all those game players out there spending their quarters to play video games?

The people who wrote those games started out with books like this one.

Get this book and try writing your own sort algorithms, use the bubble sort, the ripple sort, and then when you've got them down pat, learnthe shell sort and the tree sort.

You would think that sorting is boring,but you'd be surprised how useful they become when you want to design agame or puzzle using the computer.

And, when you learn tricks to tweakthose skills, you'll be several steps closer to selling a game toNintendo.

Get this book, and learn some good and useful programmingtechniques.

John Author of the first "Microcomputer Star Trekgame" (released for the TRS-80 in 1978). Before 1978, you could onlyplay Star Trek on teletypes and mainframes. ... Read more

Isbn: 084423074X
Sales Rank: 923226
Subjects:  1. Algorithms (Computer Programming)    2. Computer Bks - Languages / Programming    3. Computers    4. Programming - Algorithms    5. Programming - General    6. Study Guides   

Elements of the Theory of Computation (2nd Edition)
by Harry R. Lewis, Christos H. Papadimitriou
Average Customer Review:
Hardcover (07 August, 1997)
list price: $94.67 -- our price: $94.67
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Reviews (32)

A good textbook
I taught a couple of classes from the first edition of this textbook, and my students did fairly well.On the whole, they were able to understand the material and solve the homework problems.I certainly wouldn't mind teaching a class on this subject from the second edition as well, which I feel is a mild improvement over the first one.

The chapter on finite automata is excellent.And the material on context-free languages is thorough and well written.So is the introduction to Turing machines.

Of course, the book then spends a fair amount of time on recursive function theory.That is exactly what I want it to do.And I think the chapter on unsolvability, starting with the Halting Problem, is excellent.

The style, especially of the first edition, is a little formal.But this is serious mathematical material, and I think it is not asking too much to require students to handle this subject in such a manner.

First and foremost, a math book
I enjoyed this book because I enjoy formal mathematics.This is not an applications book, but a formal study of the mathematics that underly algorithmic design and analysis.I'm no math wizard, and I found this book readable (but I had to take it very slowly).The course for which I bought the book only covered chapters 1 - 4 and glossed over the final 3 chapters, but I intend to read the rest over the summer between semesters because it's so well and thoroughly written.This book is *dense*.I had to re-read everything three times before I absorbed it all, but ultimately I've understood everything I've read.The hardest parts to understand were the formal "proofs by induction" on the lengths of strings and sets - and, as any math student knows, you can gloss over the proofs on the first reading.A lot of the formal definitions (finite automata, pushdown automata, Turing machines, context-free grammars, etc.) baffled me on the first reading, but after reviewing the examples and working through a few problems, I could go back, re-read the formal definition and understand it.

My principal complaint with this book, and the only reason I gave this book a four-star review instead of five, is the same complaint I have with a lot of other textbooks - there are no answers for any of the problems (nor can I find a supplement or a study guide or any help anywhere).Given the nature of the problems themselves, it's impossible to verify your answers.This seems to be a trend in textbooks, and it's extremely frustrating.I plan to self-study the last half of the book in the next few months, but without a self-study guide, I'm pretty much out of luck if I can't solve a problem.

A reference at best, a textbook from hell
I took a Theory of Computation class with Harry Lewis, one of the book's author this last semester at Harvard. Lewis may be a gifted professor, but if you are looking for a textbook, look for something else (Sipser would be a much better idea). It is impossible to learn from this book; the examples are too complex, the questions are outlandishly difficult. I got my A but it was not thanks to this book. Steer clear. ... Read more

Isbn: 0132624788
Sales Rank: 180081
Subjects:  1. Computational complexity    2. Computer Bks - General Information    3. Computer Books: General    4. Computer Mathematics    5. Computer Science    6. Computers    7. Discrete Mathematics    8. Formal languages    9. Logic    10. Logic, Symbolic and mathematic    11. Machine theory   

Computer Organization and Design Second Edition : The Hardware/Software Interface
by David A. Patterson, John L. Hennessy
Average Customer Review:
Hardcover (01 August, 1997)
list price: $89.95 -- our price: $89.95
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

This textbook provides a basic introduction to the fundamentals of current computer designs. As the title suggests, the text skirts the border between hardware and software. After an overview of the subject and a discussion of performance, the book launches into technical matter such as instruction sets, how they are constrained by the underlying processor hardware, the constraints on their design, and more. An excellent critique of computer arithmetic methods leads to a high-level discussion on processor design. Following is a great introduction to pipelining, nice coverage of memory issues, and solid attention to peripherals. The book concludes with a brief discussion of the additional issues inherent in multiprocessing machines. The extremely lucid description is grounded in real-world examples. Interesting exercises help reinforce the material, and each section contains a write-up of the historical background of each idea. Computer Organization and Design is accessible to the beginner, but also offers plenty of valuable knowledge for experienced engineers. ... Read more

Reviews (48)

Verbose, boring, disorganized and skips important concepts.
This book starts off nicely and explains some of the basics of assembly programming (empasis on MIPS). Some of the arithematic stuff is a little out of its place and the authors skip important concepts (which I had to learn online). It has a fairly decent introduction to MIPS architecture. But right after the first few chapters - starting from caches, virtual memory and I/O this books starts to get really really disorganized and confusing. The chapter or caches and virtual memory will bore you and you'll end up spending 3-4 hours reading and giving yourself a big headache. I think topics like caches and vm need more diagrams for better understanding. Since lot of stuff happens in parallel in caches and vm's, its actually hard to understand what the authors are trying to convey from those chapters. I totally skipped those topics and studied them from elsewhere. I wouldn't want to recommend this book for students intending to go for into to computer architecture, but since this is the only book which covers all the topics, we don't have a much of a choice.

One of the better texts on hardware
If you have to use this book in a college course and you are not directed to do so, download the SPIM simulator (MIPS spelled backwards) the author mentions in the book. This can help you understand some of the more complex topics.

The reason I gave the book four stars is because the topic of pipelining as introduced in the book is confusing and may require most readers to go back over the topic several times before it clicks.

I also think that having a course in digital fundamentals prior to taking a course that requires this book would help, too. It used to be that colleges would require undergrad computer science students to take a digital fundamentals course (or equivalent) before taking and organization class. It seems now that many schools have dropped the digital requirement and have students take one computer organization class. If you fit in this boat, maybe thing about picking up a Schaum's outline on digital design concepts to go along with this book.

Very boring and tedious to read!!
This book has a good potential in teaching students about computer organization. Unfortunately, the authors spend too much time explaining simple concepts which makes the book very boring and tedious to read. For example: the authors spend 335 pages just to explain basic MIPS assembly languages and computer performance. Those concepts could have been explained in 50 pages at most. Giving too much unnecessary detail won't help me to get a better understanding of computer organization. In fact, I get lost because the main topic was buried inside all the unimportant unnecessary details. This book could have been written in 300 pages, which is about a third of the length of the book, and still gives a clear, to the point, concise explanation of computer organization. ... Read more

Isbn: 1558604286
Subjects:  1. Computer Architecture    2. Computer Architecture - General    3. Computer Bks - General Information    4. Computer Books: General    5. Computer Design    6. Computer Engineering    7. Computer interfaces    8. Computer organization    9. Computers    10. Reference - General    11. Computers / Computer Architecture