Not snob appeal. Yes, it's not a good first textbook. I taught freshman programming at Caltech for a few years, and I admit I didn't use Knuth to teach, in the sense that I didn't require the students to buy it, nor did I assign problems from it. But I *did* tell all my students to buy it (the box set) if they could afford it. And every now and then I did refer the students to look up some detail in Knuth that I felt our textbook (the also very excellent Aho, Hopcroft, and Ullman) had glossed over.

The reason is that when I prepared my notes, and when I went to class, I held a copy of Knuth in my hand. Full of post-its. It's not the best book for "learners" (i.e., beginners), but it's the ONLY book for the algorithm "pro". Sure, you can teach undergrads out of Sedgewick (Knuth's student by the way). But how do you make sure you're not missing something by using Sedgewick? By reading Knuth of course.

If I knew a bright high school student with an interest in computer programming, I'd get him the box set for Christmas. I have to admit I first ran into Knuth when I was a grade school student in the early 80s. There are lots of books in the library that a kid of say twelve just isn't interested in: whatever they are about is something that is just irrelevant and unknown. Not so with Knuth: I was programming BASIC on my C64 back then and knew what programming was. Knuth was downright scary. Here he is talking about simple things, and .... who would have known there would be so much to say about sorting???

about MIX: One day Knuth will be dead. Any programming language that existed during his lifetime will be dead. TeX will be at version pi(=4 atan 1). The Art of Computer Programming will still be relevant, most of it. This would not be the case if
the examples were coded in any "standard" programming language, with all the special-purpose things they all have (no not even if they were in Ruby on Rails!) With MIX, they will at least be in a programming notation as irrelevant then as it is now.

I have an anecdote... when I was a grad student a fellow grad student of mine had come up with a new cute algorithm using two priority queues to solve some problem in CAD. We did some literature searches.. could this be a new algorithm? Nothing came up. Search the web... nothing came up. Look in the standard books on CAD.. nothing came up. Time to publish?

Then I remembered I had a copy of Knuth (he didn't, as it's not fashionable to have forty-year-old books lying around if you're a CS grad student). Turns out the data structure and algorithm the fellow had come up with were described and analyzed in the answer to one of the exercises in Knuth's vol 3. As I recall it the exercise had difficulty level "30" (on Knuth's scale of 0-50).

I draw the conclusion that "active researchers" in a field that has anything to do with algorithms, who don't use Knuth, are at great risk of attracting ridicule for not having read up.

I re-read this book every now and then. Sometimes I read it in the bathroom. Even though I have read it several times, I always learn something new. Often on every page.

I bought the three volumes of this marvelous work in 2004.Three years later (2007) I haven't quite gotten over volume 1. Yes,the expression of concepts in the MIX machine language has tended to slow reading considerably and just when progress was being made,I encountered Fascicle 1 of volume 1 on MMIX,which I found much easier going. Other volumes I have visited as the need arose. This work is dense on content and enjoyable to read (at a pretty slow pace yes) and highly relevant to every computing problem I come across.While I may ultimately not read every page of the current three volumes,I am nevertheless looking forward to the fourth edition of this great work.

This is a classic book on algorithm analysis and also in programming techniques. The first one for which author create a hypothetical computing machine (he call it MIX), his own style to describe algorithms, a machine operation instruction and data representation, an assembly language (he call it MIXAL) for map algorithms and data structures into reality.

In another sense: it's a self-contained book.

Each chapter includes a historical review of concepts and methods.


Important topics for Volume 1
-----------------------------
* Section 1.2. Mathematical basement for algorithm performance analysis. Includes a review of Numbers, Powers, Logarithms, binomial coefficients, and also an example of algorithm analysis using "Kirchhoff's first law" for inputs/outputs (flaw to/from each step).

* Section 1.3. Description of the hypothetic computing machine (MIX): memory word, registers, comparison and overflow indicators, input/output device names, machine instruction format, machine instructions.

* Section 1.3.2. Description of the assembly language (MIXAL). Includes an interesting diagramed relation between machine instruction codes, and assembly language representation.

* Section 1.4.1. Introduce concepts of subroutine and co routine. Co routine is described as a team of sub-programs ideal for multi-pass algorithms (the kind used for processing a stream input).

* Section 1.4.3. Introduce in the field of interpretive routines and simulators. The author tells you how good programmers are at the same time good machine designers (as is the same today with virtual machines and little languages as Java). It includes a simulator program for the hypothetical MIX computing machine. You will learn how a state machine or sequential machine is implemented using a so called Control Routine (complement this reading with section 5.1 of "Computer Organization & Design" by Patterson and Hennessy - see my review for that book).

* Section 2.2.5. Describes the use of doubly linked list data structure by using a discrete simulation example (author use previously reviewed concepts like co routine and control routine).

* Section 2.3.2. Describe binary trees. The highlight of this section is a "Differentiation" algorithm. The author uses an algorithm to traverse a tree in post-order with each node representing a symbol. He then implements the algorithm using a control routine like the one implemented in Sections 1.4.5 and 2.2.5. The control routine includes a "Jump Table" for processing each node.

In resume, the book describes important topics for past and present programmers. I recommend you to read "Computer Organization & Design" by Patterson and Hennessy as an intro. Then read this one. Also you can complement this read with "Fascicle 1." by Donald E. Knuth, which describes an advanced MIX computing machine called MMIX (a 32 bit hypothetical RISC machine similar to DLX machine used on "Computer Architecture: A Quantitative Approach - 2d edition" by Patterson and Hennessy.

I do not use to speak English, but this book give a lot of theorems that cannot be understanded if we don't investigate by ourselves.

That make me a question: why I take a book if I need its bibliography to use it? Obviously, it could be I'm not too intelligent for this book. But I prefer the first tomes, where everyone can understand slowly or not every quiz.

Despite of all, this book offers us solutions in a pack (as only Knuth can do) to program the best querys when invariant is not iterable.

Would be very good were it not for MIX. Sorry, I can't be bothered with it, life's too short. Otherwise very good: clear and concise writing, all's very relevant, discussion deep, all's great -- re-write it in C and I'll give it five stars.

This may not have been the case a thousand years ago when this book was written, but today there's enough good literature of this kind to not worry about TAoCP.

The books' structure and depth are somewhat unique though, so maybe this set is worth having if you got a lot of spare time and some spare money, but remember, for most people the sample code will be inaccessible: it's written in an unreal BS assembly language.

Twenty five years ago, after five years of experience programming scientific applications (mostly math stuff, not much real programming beyond algorithms) I began a job programming business applications. At that time, there was very little general communal knowledge about very basic stuff we take for granted today like searching, sorting, memory allocation, data structures...

I began my collection with Knuth and another book (no longer in print) dedicated to data structures. These books defined me as a programmer. I learned MIX only because, as a programmer, I felt that I should be able to understand Knuth's abstraction. I admit that I was frustrated by having to do this. Ironically, even back then, the "other book" used, what was the de facto standard for generically describing algorithms, an ALGOL like language-very pretty!

Many of us have looked forward to Knuth rewriting his artful collection to satisfy our sense of aesthetics. We don't consider that he would have to repeat this huge task over and over again. Or (save me from this one) he could produce an obnoxious series of books titled "The Art of Computer Programming in C", "The Art of Computer Programming in C++", "The Art of Computer Programming in JAVA", "The Art of Computer Programming in C#", and (my favorite) "The Art of Computer Programming for Dummies". I thank Knuth for not doing this, although the last would certainly have a wide audience. Publishers know what they are about.

Another reason, in my humble opinion, that Knuth probably holds to MIX is that the latest generation of programmers do not have a clue what it is like to program a machine directly, or what is happening underneath the hood. There is a huge leap from MIX to MACRO, but the basic principles are still relevant.

The bottom line: YOU CAN COMPLETELY IGNORE MIX! All the relevant ideas are explained in simple plane English and the algorithms in structured English. Those who would prefer not to understand, but to simply cut and paste code, you are simply out of luck.

Now, if that isn't insulting enough (you caught me on a good day (after 32 years of programming I have come to hate computers and ...)) you would be amazed at how many self proclaimed senior programmers (programmers with more than three years of experience?) can't write an algorithm to save their lives.

BUY THE BOOKS! THEYRE A BARGAIN!

By the way, you all should read some of Knuth's other works. How many of us know that Knuth was an important player in getting rid of GOTO statements? I haven't written a GOTO statement in over twenty years! If my memory serves me (on a good day) Knuth wrote in an April edition of the ACM a paper titled, "Goto Bad, ComeFrom Good". He would be pleased to know that he anticipated the Publish-Subscribe Architectural Pattern.

The Art of Computer Programming is a classic work. The three first volumes cover only the basic core of programming techniques. There are enough exercices, with solutions, to keep you busy for the rest of your life. Several reviewers expressed a dislike at the MIX language used in these three volumes. But there is usually a pseudo-code description of the algorithm that can readily be converted to whatever "X" language you prefer or happen to enjoy on a particular day. I would never see Java (ouch!), C, Pascal, as being appropriate for this work. It would simply ruined the whole work. These languages have a semantics that is too imprecise. Knuth has gone one step further of including pseudo-code by providing precise code in a machine language that he has precisely described. What is needed is a new machine language closer to today's machine; and Knuth is working on that...but you will not find it in these three volumes.

Fascicle 1 of volume 1 has been published recently (summer 2005)-- for the final edition of this work with more volumes-- with a new machine language, the MMIX. It is a clear improvement on MIX. But we will have to wait for the final edition to see everything come together with MMIX. Go Don!

All three volumes of The Art of Computer Programming (TAOCP), are classic. Each is IMHO a book that every CS student should try to study reimplementing example by example. Not many will succeed to finish even half of one volume, but if you do please buy all three of them :-).

I think it's very important to study Vol 1. It gives enough exposition to the Donald Knuth style and brilliant thinking. It is the level of thinking of the author that represents the main value of the book: you instantly understand the 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)...

Please note that parts of Vol 1 on of TAOCP looks completely out of touch with reality especially MIX assembler.

Actually MIX assembler was outdated even when the book was first published and more reflects unique Knuth's background with IBM 650, not so much the state of hardware development in late 60th, 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.

But actually the statement above is not true: this is a book about timeless truths, not the book about the resent CS fashion like Java or you name it :-).

Each volume is very difficult to read; you really need to work your way thru each chapter by reimplementing the examples that Knuth gives in your favorite language (assembler might help but it is not essential).

Mathematical considerations as for average and worst running time 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. 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.
Actually the differences are so minor that are almost unnoticeable. 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.

`The Art of Computer Programming' by Donald Knuth ranks, in its field, at roughly the same level as `Statistical Methods' by Snedecor and Cochrane in statistics, `Mastering the Art of French Cooking' by Julia Child in culinary technique, and William Van Ornim Quine's book on Symbolic Logic. It is instructive to point out that as important as these books are, they are not on the same level as, for example, Isaac Newton's `Principia Mathematica' or Charles Darwin's `The Origin of Species'. That is, these are great teaching manuals whose primary achievement is in their ability to communicate their subject with their audience.

It is also important to distinguish the subject of these books from what is loosely called Software Engineering. The greatest classic of Software Engineering is Fred Brooks' `The Mythical Man-Month', which deals with big issues of software design and allocation of human resources to software projects. Knuth's books deal with algorithms. While Brooks' software engineering is similar to architecture, Knuth is dealing with a subject similar to the subset of civil engineering which deals with the loadbearing capacities of structural materials and shapes.

In my very first course on computer programming, my instructor said that programming had relatively little to do with mathematics (unless you happened to be programming mathematical calculations). The entire math you really needed to know was how to add one to a number. What he neglected to say was that computer programming has a whole lot to do with the related subject of symbolic logic which, by dumb luck, as I happened to be starting in a major in Philosophy, I was quite conversant.

So, Knuth is teaching us about algorithms which are logically based procedures, almost always involving repetition of the same action, and which can be formalized in languages which can then be fed into a computer to perform a function.

In the three volumes of the projected seven that Knuth actually completed, one volume deals with `Seminumerical Algorithms'. What that means is that his mathematical subjects are generally not the ones useful to you and me in daily life or even to a statistician, actuary, or engineer. They are typically tools used by mathematicians from which they can construct the tools used by statisticians, actuaries, and engineers, and you and me. It is highly topical to realize that one of the most important applications of Knuth's algorithms in his second volume are essential to cryptanalysis and the construction of codes. Chapter 3 on computation involving random numbers is an especially important tool of code construction and code breaking. Chapter Four, dealing with some of the basic algorithms of arithmetic is also relevant to the study of codes as it includes algorithms involving primes.

In detailing what this book does not cover, I have gotten a bit off track in dealing with Volume 2 before talking about Volume 1 and the medium in which Knuth presents his ideas. As this series was started in the mid-1960s, the number of commonly known third generation languages could be counted on one hand. In the business world there was COBOL, in the scientific world there was a rudimentary version of FORTRAN, and in the schools, there was Basic. In my first computer programming course, we learned three languages, one of which was literally a machine language punched onto paper tape, one was a second generation language on a pre-IBM 360 mainframe, and one of which was a 2 ½ generation language invented at my school, Lehigh University, called Wiz. It was a distant dialect of FORTRAN and it was strictly constructed as an educational tool. You may recall that the languages Basic, Pascal, and Modula 2 were also designed as training languages which simply busted out of their original use, in spite of serious limitations in language design.

All this is said in order to support the notion that in 1967, Knuth's inventing an assembly language (2nd generation) to teach algorithms was quite an accepted notion. So, this is what he did, and gave us the MIX language, named after the Roman numeral for 1009, which is the sum of the model numbers of sixteen different computers of the day which are similar to MIX and on which the MIX language can be simulated.

This was a time before the invention of C and UNIX when virtually all operating system software was written in assembly language. This included compilers, linkers, sorting utilities, disk management software and ... you name it, it was done in assembly language. Even a lot of applications had some assembly language routines in them for handling real processing bottlenecks.

This defines the application of most assembly language programming in its day. The main algorithms were those used in operating systems that managed the resources of the computer. And, in order to focus on the algorithms without prejudicing the dialogue by reference to a proprietary language, Knuth invented the generic MIX.

The most important contents of Knuth's books for a modern computer science student is his description of the major programming structures such as the tree, the stack, the queue, and the list plus his examples on how to analyze algorithms. Before you very modern students of object oriented programming pooh pooh something written in an assembly language, I should note that I was the hero of a major recent software project where I new how to use C to manipulate linked lists (learned from these very books), a technique for which C is exceptionally well suited, while my colleagues, all of whom, like me, came to programming from some other discipline with no benefit of formal training in programming structures.

There are certainly more modern books on these subjects, but there are probably none which are quite so authoritative and I suggest the effort in wading through the MIX language will pay off big time the next time you hit a particularly sticky application performance problem in you programming project.

I borrowed volume 2 to implement a special data structure. It helped me immensely in that task. But it wasn't the only resource I used. I could not justify spending the money on this book.

Short of the mathematical treatment, the knowledge certainly wasn't limited to Knuth. In fact, most (all?) of the Art of Programming is a compilation of ideas, isn't it?

I used a variety of resources. I even used to web. There are some terrific animations that show special case tree rotations for AVL trees or red-black trees out there.

Knuth will be appreciated by academics the most. Very specialized programmers, such as embedded designers, OS authors, or database designers will likely be the next biggest group of fans. Application developers will be next in line. They mostly depend on APIs to implement the topics for them. And Rapid Application Developers will hate the book. Don't care. Don't need to know. And they don't. So figure out where you are in that list and that's how much you need this book.

A modern rewrite would definitely nudge me into buying the book. But I just can't force hand on wallet ... to ... shell ... out ... bucks for a book that's already widely available in a variety of formats for free.

PROS:
Likely the best mathematical treatment of a computer science subject you will find. No one ties the practicality of CS and abstraction of math better than Knuth.

Coverage of many core concepts of computer science such as data structures, big-O notation and efficiency, bit wise arithmetic algorithms, random number generators, etc.

Classic work. Impress your colleagues by idly leaving the book around. Bonus points: leave it open AND have a copy of Red Dragon nearby.

CONS:
Not enough pictures. Seriously. I am a visually oriented person. Two pages of tree rotation diagrams are far more helpful than ten pages of prose.

The book is type faced as a college text. The typeface is difficult to read. The exercises litter the book and make thumbing through it a bit annoying.

MIX. This is Knuth's solution to describing algorithms in a universal programming language the audience can understand. Unforunately, the language is assembly designed for a fictional computer. So no one can understand it but equally as well. Actually, any popular assembler experience (Motorola/Intel/PIC) should span the gap nicely. But when's the last time you programmed in assembler? How come? I blew past the MIX examples and looked for better psuedocode elsewhere.

Yes, using MIX is all wrong. High-level language psuedo-code (not fictionaly assembly language) that's intuitively obvious would save us all so much trouble. But, why not a "TAoCP in FORTRAN-90", a "TAoCP" in APL, a "TAoCP" in COBOL, a "TAoCP" in BASIC, a "TAoCP" in LISP, a "TAoCP" in ALGOL, a "TAoCP in Ada", a "TAoCP in C", a "TAoCP in Java", etc. ?? Think of the money to be made re-selling it in every possible langauge if there's a market for it? I might even do it myself and make some $. LOL. Actually, there's no need for a Visual Basic version, etc. because language specific I/O, etc. is not the issue. This set is about art, about *algorithms*, so most of the high level language specific aspects are irrelevant (except for recursion, details like garbage collection, inheritance, polymorphism...).

Equally irrelevant is worrying about efficient memory usage and the like. Today, memory, disk space, etc. are not scarce resources. While (being from the old school) I don't believe in wasteful code, all people really want today out of algorithms is optimal speed. Time and CPU power are the only resources that are still constraints (aside from transmission speed). Discussions about sort algorithms which optimize for anything else (memory space, etc.) are pointless if they aren't also the most time efficient. We don't care! Also, unless you work for the US Census or Social Security Administration, you don't care about hardware devices like magnetic tape drives, so those algorithms are just theoretical mind games. Anyway, please rewrite this set in a practical high level psuedo-code with time optimal algorithms only. But only the timeless (pun-intended) universally necessary algorithms that are always going to be useful. Stuff like searching, data structures, hashing, trade offs between techniques. In the future all people will want are
parallel processing algorithms for distributed environments and perhaps eventually quantum computing algorithms for a language built on a CPU which only processes QBits.

One final thing: wasn't there originally supposed to be 7 volumes and only these 3 were completed? What ever happened to the rest? [Update: After 32 years, Knuth is finally dribbling out volume 4.]

I was amazed to see some people dissing TAoCP. I came across these books 20 years ago when I was learning FORTRAN and Pascal. I did not understand much then but since then they have proved to be the best source for solving many sticky problems be it data structures oo sorting. It is true it uses MIX and does not cover the last 20 years of advances in computer science yet but if you cant understand MIX you have no hope of understanding the mathemtical analysis of algorithms in these books nor appreciate a quality book like this. If your intellectual curiosity extends beyond the O'Reilly cook books and you *love* programming, these books definitely belong in your library. A couple of hours of reading a section or two from these books is so stimulating!

People buy Knuth's books for snob appeal, which is to say that they like to put the 3-book set on their shelves as an advertisement for their own intellegence. What they don't realize is that truly talented individuals will see beyond this kind of cheap PR stunt. "Look, I read Knuth... boy, I must be a genius!"

Donald Knuth obviously has offered extra credit to students who provide him with glowing reviews on amazon. "Oh geeze, this is the best book ever. Bow down and kiss his feet." For all we know, he may even offer a cash reward.

This is just one of those cases where the myth of Knuth has overshadowed reality. Is Knuth well known? Yes. Has Knuth been around forever. Yes. Has knuth published countless articles? Yes. Are his books used in day-to-day coursework at top-ten engineering schools. NO, THEY ARE NOT.

For data structures, most *working* professors would refer you to Cormen, Leiserson, and Rivest (or maybe Robert Sedgewick). For scientific computing, most *active researchers* would suggest a book like Michael Heath's. For random numbers, you'd be better off with Kelton and Law's book on simulation. For computer architecture, everyone uses Patterson and Hennessey. See a pattern here?

The truth is that fields mature, and textbooks get better and better. Knuth has decided that it's too much work to stay current; he'd rather stick to 6-bit MIX assembler code and his precious universal truths.

Well, Professor Knuth, I have news for you: there are more recent books out there that do a much better job at stating "universal truths" with the added benefit of being easily readable.

I don't buy the excuse that it's too much work to re-write code examples in different languages. Isn't this what graduate students were made for Prof. Knuth? Hell, you don't even have to pay them that much. Just try not to speak down to them, oh great one.

I also don't buy the excuse that he uses MIX so that the reader can look at the finer details of performance and memory consumption. Isn't this the same man who said that "premature optimization is the root of all evil?" In other words, don't optimize; use a better algorithm. You don't need to look at assembly code to analyze algorithms, O(n) analysis should suffice...at least, it's more of a "universal truth" approach.

By trying to write a complete survey of computer science, Knuth trys to be everything to everyone. In doing so, he does nothing as well as he could have (and certainly not as well as the textbooks currently being used). What he has ended up with is an expensive white elephant, that will look pretty while it collects dust.

Stop making excuses Professor Knuth. Get off your...organ and get back to work.

This is the foundation of any computer scientist's library. While certainly NOT light reading, the wealth of information contained in these volumes is relevant to a variety of real world problems in computing. While few people may be willing to commit the time and effort to read all three volumes, those who do will find themselves among the most informed and fully grounded professionals in computing today.

A generation grew up on Knuth, yet many new coders simply do not know who he is.

The Art of Computer Programming is required reading for anyone serious about computer programming, it is as simply as that.

It is with good reason that these books are so well-respected in the field. These books have enough depth for several years of careful study and will be quite rewarding for anyone who takes the time. Still, there are a couple of things to keep in mind before jumping in:

(1) These books are not for the mathematically weak-at-heart. The first section, of over 100 pages, is on mathematical preliminaries. While it is true that there are many later sections that can be understood without this background, to truly get the most from these books will take some mathematical maturity,

(2) The algorithms and programs in the book will be difficult to understand to the modern reader, since they are written in an unstructured (i.e. GOTO-centric) style. Program code is given in assembly language for a fictional computer called MIX. Knuth may have his reasons for sticking with this form, but the reader should be aware that some extra work will be required to follow along.

Aside from these caveats, these books come highly recommended.

These three books are amazing. A deep, definitive coverage of the theoretical basis of computer science. In fact, to the extent that computer science is a science, you should refer to these books, if you are ever in doubt. As a measure of how well regarded these are, Knuth mentions in his home page that American Scientist magazine ranked this amongst the top 12 scientific monographs of the twentieth century, alongside books by Einstein, Dirac, Pauling and Feynman.

Much of computer programming and usage today builds upon the algorithms described in the books. What does it mean to have a "good" random number generator? What are quantitative tests for randomness? How can you efficiently sort a list? How do you find the greatest common factor of two (large) positive integers?

It is true that the typical computer programmer does not know most of the material in the books. This is because she usually can access subroutines that come with the language or are in standard libraries that implement the core algorithms. For example, in Java, there is a routine called Collections.sort(), which you call with the name of a list in the brackets, and the routine will sort it.

But within the field of computer programming, sometimes you may be called upon to implement those core algorithms. So what do you do? Turn here for help.

The books are also graced with a vital attribute. Each section of a chapter has a set of questions. Typically these are tough; they can keep you busy indeed. Plus, Knuth supplies the answers. The combination is a great learning experience. So often have I wondered at textbooks that don't supply questions. Students need hands on experience.

Knuth's set of books on the Art of programming are excellent academic books. However, I should like to warn everyone that they are not practical programming books. For one thing, they examine each subject in extreme detail. Someone looking for a quick review of sorting, for example, will find page after page of mathmatical formulae and definitions, detailing not only sorting in general but total orderings, keys, data structures, etc. Also, don't expect to steal any code from this book. All the algorithms are written in MIX, a hypotheical assembler language for an abstract machine. In fact MIX is so out of date, and the abstract machine so primitive, Knuth is promising to update both - but not very soon.
In short - these are great books. But they're not light reading and they are geared more for academic study rather than practical use.

The three volumes of the original version of "The Art of Computer Programming" are more than thirty years old now. I still have the edition I bought back in 1978 or so and they're never too far from the "easy to reach shelf" in my bookshelves. Sometimes I rearrange things and move them away, always figuring that newer books will work as well, but somehow they always move back - not always quickly, but rarely too slowly.

Sometimes its because I just want to reread something, sometimes its because I want to challenge myself with one of the problems, but often enough it is because I find myself needing to supplement information from somewhere else or because I just can not find quite what I need anywhere else. And I will turn to the web to search for things - but first I usually check out TAOCP.

It can be tough going in some places, the math sometimes reaching the "AAArrrggghhhh, run away, run away" kind of appearance, but a bit of work almost invariably pays off.

This is not a book from which you will learn to program. You should have some facility with more than college freshman level mathematics. And you'll need to read things more than once in many cases.

If you're an IT person, a software installer type, a low level coder or the like and are content with this, you can probably afford to avoid ever reading TAOCP, but if you want to solve the hard problems, if you want to learn just WHY things work, and learn the mathematics and the kinds of analysis techniques that make the difference between the grunt programmer and the really good ones, you'll need the math, you'll need the kind of information, knowledge and computerology-goodness-and-niceness that TAOCP (and few books other than TAOCP) can give you.

Seeing a well used copy of TAOCP on a computer professionals bookshelf is always a sign to me that they're serious about their profession and about their own learning. Not seeing one is often a flag that they're someone I'd rather not have on a project I'm involved with. Worse yet not seeing TAOCP on a CS professors bookshelf leads me to the impression that professor is at best semi-educated, and at worst one of those frightening types who managed to slip through the cracks somehow.

Now I'm waiting for Volume 4 (and all the rest). (Interestingly, I got one of those mail back cards from the publisher about 4 years ago asking me if I wanted to reserve a copy of the "soon to be published" V4 - I could not resist calling and asking lots of details about it.)

I was also lucky enough to find copies of the original editions of V1 and V3 two years back in a booksale for a grand total of about a dollar. Now now I have 1.101010... (in binary) sets. If V1-4 get published in a boxed set I'll undoubtedly spring for the set at whatever price.

Knuth is no doubt the authority on the subject.

This timeless classic is bound to make the student (Yes you ought to be a dedicated one..no casual reading here!) proficient in the art and science of constructing programs.

This is both a textbook that teaches you how to approach the art of programming and a lifelong reference to which you keep going back to.

There are tons of books on data structures, programming, algorithms ...right? wondering Why you want to pick this one? well...because, almost every book traces back to this!!

To be fair to the other books on the subject, one must admit that this book is not for everyone. If your needs are to get up to speed on say, developing web applications or database applications that does what most applications do, then you should pick a book focussed on those areas.

This collection is aimed at someone who wants to get a thorough grinding on the art of writing programs of *ALL* kinds. Be it a memory management module, or a task scheduler or a efficient graph implementation or a database engine or a webserver or ...well the list is virtually endless.

Being independant of any domain you are interested in, but treating each and every aspect of programming to an extraordinary detail, that you can apply to any possible domain imaginable is what makes this a timeless classic.

This books develops considerable amount of math needed for quantitatively analysing the programs for its time and space complexity.

Interestingly it uses assembly as the language. you can see the author's opinion in one of the comments here, which I think makes sense.

The exercises come in quite a range. Trivial one minute problems to unsolved research problems! (No..Seriously).

To summarize, this is a great text for some one embarking on a long journey into truely mastering the art of computer programming !

When I first started reading Vol#1 in 1970, I was throughly ignorant of Computer Science. I could merely program in Assembly, FORTRAN, and SAIL (a variant of ALGOL, then used in AI research). In the intervening years I have learned and used dozens of computer languages, earned a Master's and two Doctorate's and became a Director of CS at MIT (EE/CS) and Stanford (CSLI). I completely wore out a Vol#1 and applied significant wear on #2 and #3. While there are hundreds (if not thousands) of other computer books in my head, THESE produced True Understanding. Not for wimps or ignorant wannabe's or Micros**t style "programmers". O'Reilly publishes great stuff "In a Nutshell", but sometimes you want (or need) to go deep. Here's the Real Stuff.

Having seen loads of reviews about this book being essential for any computer programmer, I am disappointed to learn that this actually means only Machine Language programmers. Not C, not C++, not Fortran, Cobol or Delphi...Not even Basic.

The author has seen it fit to ignore all popular programming languages to use for his examples' code. Instead, he uses a meta-Assembly language which he has made up out of thin air, for this important purpose.

I can't tell you how p***** off I am not to be able to understand a damn word of his coded algorithms. The excuse of being able to go 'low level' inside the computers memory and such is too thin, I would happily pay twice the marked price if the examples were in C, C++ or any language higher than this indecipherable pseudo-ASM!

It is such a shame that this is the case because the books are of a very high quality indeed, the author has a rare talent for conveying these fantastic concepts using plain english, but I'm at a loss as to how to implement tham on an actual computer. Which rather defeats the point of this set.

And to make things worse, its not even a standard ASM dialect, not even close.

Unless you are an ASM god (at least you shouldn't have any trouble understanding and 'porting' his pretend code) and/or Masters degree mathematician, I would steer clear of this one.

Why why why not C++, Mr Knuth, please tell me! :(

For anyone who is new to computer programming and wants to get a indepth background of its history and evolution, I DO NOT recommend this book. When I received it I was very excited because it came in three nicely bound hard cover volumes. But, when I looked inside, all I saw was massive amounts of mathematical equations. I felt like I was reading a mathematics book and it was completely unreadable, overwhelming, & intimidating. I guess, being a novice, I expected something much more readable. So, I blame myself but for anyone like me who thinks the title of the book will give them an enjoyable "read" on computer programming...forget it.

Every serious computer science student will see repeated references in other books to this wonderful set by Donald Knuth, professor emeritus of computer science at Stanford. He is acclaimed by many as the foremost computer programmer in progamming's brief sixty-year history. Its the best resource for the typical algorithm problem sets in most, traditional C and C++ courses. Those who see and enjoy programming as applied mathematics will find some spare cash to buy it.

Having this set on the shelf is somewhat like having a set of Shakespeare - its the best but not for everyone. One kind of expects to find Volume 1 of this set in the nightstand drawer at Silicon Valley hotels.

if you consider yourself a "programmer" you must have, and not just have - you must read these books!

I am a 15 year old CS enthusiast and serious programmer. I had been told about the legendary writings from the one that they call Donald Ervin Knuth and promptly purchased his three volume set.

I really enjoyed the volume on sorting and searching and also the chapter on random numbers in vol. 2. All of the volumes contain very valuable information to anyone in the CS field. I am eagerly awaiting the release of the next volumes(Vol. 4 - Combinatorial Algorithms, Vol. 5 Syntactical Algorithms, Vol. 6 - The Theory of Languages, and Vol. 7 - Compilers). I too enjoyed the fact of him not using a HLL to show the examples and implementations of the algorithms in the book. Machine languages do have less abstractions and don't distract the reader from the concept being discussed. Mr. Knuth is a wonderful writer and teacher.

I really enjoyed these books and I believe that it would a be a necessary addition to any CS or programming enthusiasts' library. If you are serious about CS, get these books.

I have all editions of this Bible of C.S. by the superhacker Don Knuth - if you are serious about C.S./programming/concrete mathematics, you got to buy the latest editions (at least). The number of people eagerly awaiting vols. 4 and 5 (due c. 2003) must be huge.

I wish that Ch. 3 (vol. 2) had a more detailed treatment of cryptographically secure random numbers. (There is some coverage, mainly in the exercises). Evidently Don Knuth believes that there is not yet enough material on that subject that will stand the test of time.

Knuth is obviously in the eduction business. This is a book written for learning from. It's very easy to ignore the parts that are too detailed for your needs and not feel like you've missed something. My favourite parts are his historical notes. These are the reward for ploughing through a section, some of them quite facinating.

I'm a compiler designer. Compilers like most other big applications are built on stacks, queues, lists, trees, etc. These books will teach you how to implement these structures solidly and effeciently. Alot of my time at work involves reading research papers on optimisations. I need to understand how algorithms are analysed and how to compare two algorithms. These books give the mathematical tools needed to perform that job. Some criticise his using a machine language for examples. I personally think that this is a good thing. Seeing something done in assembly shows you how easy it really is. Sometimes hhigh level languages with all their abstractions make things look more complex than they need be.

These are really great books. If you are serious about algorithms and you are serius about data structures than this is a book you are looking for. But you should be Intermediate level programmer to read these books. Chapter on sorting is really a great one. Knuth has done a great job on this chapter.

I enjoyed this series of books tremendously. Detailed explanation of various algorithms. Uses a fictional MIX assembly language machine to show code examples. This is unusual, but turned about to be very very helpful. The excerises at the end are have a rating of how difficult they are to solve, so you can choose which ones u want to tackle. Detailed answers for almost ALL the problems at the end of the book - always a plus!

OH .. and there are some problems marked "Unsolved".. If you can solve any of these, you might just be able to get a PhD for it :)

These books are indisputably classics of the field, and like all classics they have religious adherents and equally firm detractors. The key difference between the two groups is that the adherents are interested in computer SCIENCE, whereas the rest are more taken with computer programming. The books are well written, quite mathematical, and abstract. The books deal with the core subjects of computer science and shy away from the trendy, and so some people tend to see them as anachronistic. Nevertheless, they are deservedly core references in computer science, and a joy for any patient, theoretically minded reader. There are three points I believe should be made. 1) a lot of the detractors of the books are saying correct things: the books don't deal with hot topics, they do present things in greater detail than is necessary in day to day programming, they are books they require a lot of the reader. What they don't recognize is that this is the intention, and that there is nothing wrong with that. The book is targeted at those with a geniune interest in theoretical computer science. 2) many reviewers complain about Knuth's typesetting system, TeX. What they fail to recognize is that TeX is incredibly useful, and about as user friendly as could be expected, for the task for which it was designed: typesetting professional quality mathematics. Anyone who challenges this statement would have to contend with virtually the entire community of people who write papers using higher mathematics, including virtually all professional physicists, mathematicians, and computer scientists. 3) some people accuse Knuth's books of being poorly written. These people are ignorant: either they have not read the works, or they would not recognize skillful writing if they saw it. These books are splendid examples of scientific writing, and are justifiably acclaimed as such. In short, Knuth's books have ensured that the word "science" deserves its place in the phrase "computer science"

These books are indisputably classics of the field, and like all classics they have religious adherents and equally firm detractors. The key difference between the two groups is that the adherents are interested in computer SCIENCE, whereas the rest are more taken with computer programming. The books are well written, quite mathematical, and abstract. The books deal with the core subjects of computer science and shy away from the trendy, and so some people tend to see them as anachronistic. Nevertheless, they are deservedly core references in computer science, and a joy for any patient, theoretically minded reader. There are three points I believe should be made. 1) a lot of the detractors of the books are saying correct things: the books don't deal with hot topics, they do present things in greater detail than is necessary in day to day programming, they are books they require a lot of the reader. What they don't recognize is that this is the intention, and that there is nothing wrong with that. The book is targeted at those with a geniune interest in theoretical computer science. 2) many reviewers complain about Knuth's typesetting system, TeX. What they fail to recognize is that TeX is incredibly useful, and about as user friendly as could be expected, for the task for which it was designed: typesetting professional quality mathematics. Anyone who challenges this statement would have to contend with virtually the entire community of people who write papers using higher mathematics, including virtually all professional physicists, mathematicians, and computer scientists. 3) some people accuse Knuth's books of being poorly written. These people are ignorant: either they have not read the works, or they would not recognize skillful writing if they saw it. These books are splendid examples of scientific writing, and are justifiably acclaimed as such. In short, Knuth's books have ensured that the word "science" deserves its place in the phrase "computer science"

I am just buying another set since my first set got damaged in transit. This is a great book for a programmer and anyone who thinks otherwise, atleast in my humble opinion, is not a computer scientist. It is detailed, mathematical and has tons of great problem organized by difficulty. I can safely challenge anyone who doesn't appreciate this book, to solve some of the more diffcult problems.

Great book !!!

Knuth covers th emost obscure aspects of computing science with a pedants zeal. The pointless waffleing prowse hides little or no understanding of computing in a modern enviroment. Any man who uses TEX, let alone invents it deserves not our admiration but our sincerest pity.

If you want a book that actually helps you with a task rather than dresses up the subject in obscure techno babble then get a Nutshell guide from O'Reilly.

This is a work of surpassing beauty, akin to Beethoven's Fifth. This book introduced me to the joy of computer science and still fills me with wonder that one man could do so much.