Your Garage botysf16 Amazon Fashion Learn more Discover it Drowners Fire TV Stick Subscribe & Save Patriotic Picks Shop-by-Room Amazon Cash Back Offer WienerDog WienerDog WienerDog  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Introducing new colors All-New Kindle Oasis Segway miniPro STEM

Your rating(Clear)Rate this item

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

on November 10, 1997
Anyone who aspires to be a transcendent programmer must own (and use) Knuth. I've used my 20 year old TAOCP vol. 1 so many times over the years that it lays flat at any page.
The updated volume 1 is more of the same - a classic revisited, revamped, restored. It is odd to handle something so familiar, yet so crisp.
Those who dislike MIX will be unimpressed - to them, I say that you don't learn by doing the same vanilla thing time and again, but rather by wrestling with unfamiliar concepts and architectures. Many times my fellow programmers will find themselves roadblocked in an unfamiliar situation, while I often can see the unobvious solution - I attribute this ability to a wide experience with unconventional solutions, including extensive study of Knuth's TAOCP.
If you're serious about your programming abilities, you *must* own (and study) this book! Frankly, if computer science were taught as an apprenticeship, this would be the journeyman's manual. I've required the many programmers I've trained over the years to own and study TAOCP, and they've all come to appreciate it's layered approach to problems - you can read Knuth at many levels, from algorithm reference to meta-analysis of an entire class of problems.
If there is a Koran, Bible, or Tao of Computer Science, this is it. The only thing close is Aho's "Dragon Book," and it's specific to compilers.
0Comment|54 people found this helpful. Was this review helpful to you?YesNoReport abuse
on January 1, 1999
When I read Knuth #1, I was an English Major with a certificate in COBOL programming. Alot of what he said made no sense; after struggling for 3 weeks I began to understand. I used Knuth to learn QA, testing techniques, structured analysis; Knuth was my Harvard & Yale of programming knowledge.
I read the poor reviews of Knuth here & I think: THEY must be lazy, really lazy. If you want to work hard & have NO Background in CS other than a programming language you really know YOU can master this book. Yeah the math & true CS graduate can read this easier than me, but can they owe a lifetime of programming methodology to it?
I owe everything to Knuth; I love the man.
22 comments|53 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 15, 1999
I read this book when I was a sophomore in high school and I thought it was excellent. Prior to reading the book, I had wanted for a long time to write a program to evaluate standard mathematical expressions. I had even tried once before, but I didn't know enough about what I was doing to be really successful. Somewhere in the second chapter in a discussion of lists, doubly-linked-lists, and binary trees, a good solution came to me, and I implemented it right after I finished reading the book. It worked very well. This book helped me to accomplish the major goal-project of my computer programming career so far, and I definately think it is worth reading for anyone wanting a really advanced understanding of fundamental algorithms. Now I know to many advanced means total [over]use of fully encapsulated C++ objects, which this book doesn't have, but this book gives an advanced understanding, which is infinitely more valuable than classes. If you understand OOP and you understand this book, you should be able to combine the two just fine. Lastly, I'd like to comment on the use of MIX. I read almost none of the MIX assembly code when I read this book. The little I looked at I looked at because I wanted to see what assembly was like in the 60's. But you can understand everything he's trying to say by his explanations of the algorithms, the assembly code is only for clarification, and you don't have to read it. I also believe that everyone who's been using fully encapsulated classes for their entire programming career should learn an assembly language sometime. Just like this book, it will teach you how to think.
0Comment|36 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 29, 1997
Knuth has finally updated the three completed volumes ofhis exceptional "The Art of Computer Programming" series,correcting errors and updating the topics to includestate-of-the-art algorithms while retaining the basicstrengths and weaknesses of the books. This comes as arelief to many old-time programmers who, watching Knuth's20-year diversion in pursuit of typographic perfection, hadbecome convinced he was NEVER going to get around tocompleting the remaining four volumes of the series.
The series's strength is its exhaustive survey and deepscientific analysis of the many algorithms applicable tothe areas of computer science covered. No other book orseries comes close in providing the reader with the toolsto understand and develop algorithms and to choose amongthe alternatives available when faced with a programmingchallenge requiring an algorithmic solution.
Knuth's primary weapon for analysis is mathematics and hedoesn't hesitate in beating algorithms to death with abarrage of equations; in fact, on a few pages a reader canfind up to thirty summation signs. So a warning is inorder: readers with math anxiety are likely to be reducedto a state of insensate palpitation. Yet the books containvery little calculus or other higher mathematics and thus acollege sophomore should be able to follow the discussion.Also, the reader can skip all the proofs on first readingand simply trust that Knuth is telling the truth.
Surprisingly, the series contains much background materialon the history of computer science and quite a bit of wryhumor. It is about as lively as can be expected of a seriesso deeply technical.
The series's greatest weakness is the MIX assemblylanguage, which Knuth uses to illustrate algorithms, almostalways after first describing them in English. Althoughassembly language is necessary in order to maintain Knuth'sdeconstructionist approach, MIX is deeply rooted in the1960s concept of a computer, with no stack orgeneral-purpose registers. Worse, a reader returning to thebook after letting it lie fallow will find the MIXinstruction mnemonics are needlessly cryptic (What do"ENNX" and "JBUS" mean!?). Perhaps Knuth will update theinstruction set or improve the mnemonics in a futureedition.
To sum up, I'd like to repeat some advice that was given tome in 1974 and is still true today: "If you want to be aprogramming technician, read about the latest programmingfad. If you want to be a computer scientist, read Knuth."
-- Glenn Fawcett
11 comment|22 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 22, 2004
Some of the reviews here talk about how this book is not immediately useful for practical ends, and go on to say how MIX is obsolete, one doesn't have to know assembly anymore and so forth. I think they have missed the point. This series of books definitely emphasize the Science in Computer Science. They are scientific works, and are not meant to be immediately useful so that you can learn how to program an e-commerce site on a Windows 2000 server. If you want to learn that, go buy another book. If you want to learn about the most efficient algorithms capable of solving problems, if you want to learn the mathematical basis of how problems can be solved with computers, and how to do it on the underlying hardware, directly, with assembly code, this is the book for you. This is Knuth's life work, and an attempt to really contribute to capital C Computer capital S Science. It is not "Teach yourself programming PHP in 30 Days", if that is what you're looking for, you should certainly buy another book. If you are looking for what Knuth intended, this is the best that's currently out there.
11 comment|19 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 20, 2005
All three volumes of The Art of Computer Programming (TAOCP), are classic. Each is a book that every CS student should try to study diligently reimplementing example after example. Not many will succeed to finish even a half of one volume, but if you do please buy all three of them and think about post-graduate studies :-).

I think the most important is to study the Vol 1. It gives enough exposition to the Donald Knuth style and brilliant thinking. While the content is definitely important it is the level of thinking of the author that represents the main value of the book: you instantly understand the book was written by a great scientist and it does not matter much that now the contents of most chapters can be significantly improved using more modern sources. After all Vol 1 is more then a 30 years old book (it is older then Unix) and as such it should be outdated (we all believe in progress, don't we)... And it is not surprising that parts of Vol 1 on of TAOCP today look completely out of touch with reality especially MIX, the CPU instruction set that is used in all volumes.

Actually MIX instruction set (and thus assembler) was outdated even when the book was first published and more reflects unique Knuth's background with IBM 650. It was far from the state of hardware development even in late 60th when the first volume was published, the period when IBM/360 was the king of the hill.

Now IBM 650, a 1,966 lb machine that consumed almost 30 Kw of electricity looks more like a primitive calculator than a real computer: typical installation has the memory of just 10,000 decimal digits ( 1,000 words; 10 digit per word).

It's really sad that Knuth did not adopt System 360 architecture and PL/360 assembler (Wirth's structured assembler for S/360) for his books but we can do nothing about it. Still this is a book about timeless truths, not the book about the resent CS fashion like Java or you name it :-). It actually can serve as a perfect antidote against any current CS fashion.

And Knuth does provide pseudocode with his natural language algorithm description. And natural language pseudocode has an important advantage over 'structured pseudocode. The problem with a "structured pseudocode" is that the set of control structures is fixed and may not reflect the needs of a particular algorithms (branching out of loop is a common problem that is not addressed by structured programming well). Moreover it can cripple the algorithm by enforcing unnatural control structures, the structures that are absent in it but might be present in more modern languages. For example Perl has an interesting set of control structures that is superior to C. But even "Perl control structures set" can be improved further.
That's why assembler language is preferable: it never obscures "natural" control structures for each algorithms, structures that one day can be mapped into some new elegant language construct. Also as one review noted "sometimes high level languages with all their abstractions make things look more complex than they need be."

I would like to stress it again that each volume is very difficult to read; you really need to work on each chapter by reimplementing the examples that Knuth gives in your favorite language (assembler might help but is not essential).

Mathematical considerations as for average and worst running time of a particular algorithm can be largely ignored during the first couple of years of study of this book. Actually most mathematics in Vol. 1 can (and probably should) be initially completely ignored. See Softpanorama Classic Computer Books for more information.

On the negative side this is an overpriced book, if we are talking about students budget. To save money you can buy one of the first editions: there is not that much difference in content to justify the differences in price. The differences do not interfere with the study of the book. Knuth did an excellent work the first time he published each volume and for a significant improvement we probably need another century and another person.
11 comment|17 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 9, 2006
"The Art of Computer Programming" (TAoCP) is about machines and mechanical methods.

TAoCP is "about timeless truths" as the author writes. It's about CPU registers and memory cells. It's about counting the number of machine cycles a program will take. It's about precision. It's not about creating fancy Excel macros or adding pop-up windows to your web page.

Volume one contains two chapters. Chapter One first defines algorithms, gives basic math concepts for computer science starting with Mathematical Induction, continuing with a section on how to analyse algorithm, plus a couple of sections for people familiar with mathematical analysis (i.e. the math behind calculus). It ends with a complete description of MIX, a fictional computer, and of the machine language for programming MIX. (Note: MIX will soon be upgraded to the equally fictional MMIX). I won't repeat the author's rationale for sticking to machine language, and a fictional one at that! Suffice it to say that he has his reasons.

Chapter Two is about lists and trees, the most fundamental of data structures. Stacks, queues, and deques are lists with one or two entry and exit points. Linked lists have as many entry and exit points as there are elements, but careful! you need to worry about linking elements to one another, and ending with correct linking when adding or removing an element. And then there are trees, and the many ways to visit all nodes in a tree exactly once. Leftmost node first? Last? Middle node first?

Who should read this then? Patient people! Knuth published the first volume in 1966 and plans to finish the final edition of the fifth volume in 2015. This is not a For Dummies book, so don't expect to speed read through it. I skimmed the whole thing cover to cover, skipping the exercises and occasionally working hard at achieving perfect understanding of two or three pages (several hours!). I'm now going through it again more slowly, part by part, doing some of the problems. If I want, I can have fun with this book for the rest of my life.

Apart from that, well obviously computer science academics will enjoy TAoCP and find inspiration here for classes and tutorials. This is a monograph, so it is complete and mostly self-contained. It is also accessible to anyone willing to put in the hours to read it, and very little beyond a little programming experience is required.

Most of all, TAoCP is for people who enjoy thinking for its own sake, people who enjoy puzzling out and finding tricky solutions to what might seem like a straightforward problem. Some people enjoy tinkering with cars, others like building model ships. Like these activites, going through the exercises in TAoCP gives us what Fred Brooks calls the sheer joy of creating things.

By the way, it's worth learning MIX. I do the exercises in Perl (egad! I can only handle some of the problems...) but since the solutions are in MIX, it pays to know it well enough to read through Knuth's examples.

Vincent Poirier, Tokyo
0Comment|15 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 1, 1998
This series (TAOCP) is for people who have the passion and the vision to chart new areas in Computer Science. This is not for those who merely wish to make a living in computing industry. The exercises forces you to think in a fundamentally different way, not a temporary solution but an elegant solution. If people had read and followed, we would perhaps not be grappling with Y2K as we are doing today.These books are must have for any serious CS person.
0Comment|9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on February 3, 2000
Well this book is a good and a complete book. Many of the readers who are veterans may want to read more about algorithms and data structures require this book.
The book is complete and well formed. As for the Mix code(assembly) it is his way of telling us how to integrate the algo. into our coding. You must have a lot of patiences and dedication in reading the book. This book is not for amateurs. They must have at least a firm understanding of assembly language prior to reading this book.
The reason I bought all the books is b'cos it saves a lot of money. Imagine that you buying data structures for each language. Still the books does not allow you to port over the data structures to other languages(c,c++,java,pascal,.....). It is a de facto in algo. and data structures. This book is a great reference.
Ps. don't buy it if you just want to use data structures and algo. quickly.
11 comment|11 people found this helpful. Was this review helpful to you?YesNoReport abuse
on December 22, 1999
This book is the bible of computer programming. It contains fundamentals of algorithm complexity theory, with O-notation, and data structures, including lists, trees, graphs, sets ect.
The only drawback of the book is that all algorithms are written in MIX - some kind of assembler, so they are really hard to read.
11 comment|12 people found this helpful. Was this review helpful to you?YesNoReport abuse