 "Painful" | 2008-06-04 |
| - Reviewed By mcgurk23 |
Yes, I know, we devs should all pay homage to the great Knuth. I don't dispute it. But I also don't want to read a textbook. That's what this is. And unless you're writing low level algorithm libraries, you have no business reading this book. 'Cause if you can't grasp the basics already, this book will do more to scare the crap out of you than anything else.
For the hardcore only! |
| |
 "Algorithms, Data Structures, Computing Machine, Analysis" | 2007-10-01 |
| - Reviewed By tobigaba |
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
----------------
* 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 (flow 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 figure on 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 coroutine and control routine). You learn how the idea of coroutine is a base for discrete simulations. Also, author use what he call a "pseudo parallel procedure": a WAITLIST. This kind of procedure was used during 1960s and 1970s as a multi-task procedure.
* 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. Also, "The Art of Computer Programming, Volume 3" will very useful (Balanced Trees algorithm for example, as a "self-reshaping" structure).
|
| |
| "Just try sorting and searching with out this book." | 2006-06-17 |
| - Reviewed By bernie-at-nationwide-net |
This book has saved my bacon several times through the decades. Once I needed to actually build a database package from scratch instead of using a commercial package.
I almost did not buy it when all I saw in it was mostly math. But I was desperate and it paid off. Turns out you could not explain it any other way. I use it primarily for balanced trees. I may try some thing more exotic later.
The set also looks impressive in the library.
|
| |
| "Mechanical things: foundations" | 2006-03-10 |
| - Reviewed By vincentpoiriertokyo |
"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 |
| |
| "Vol 1 is the most important in the series and is a must for CS students" | 2005-11-20 |
| - Reviewed By kievite |
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.
|
| |
| "As good today as ever it was" | 2005-11-05 |
| - Reviewed By blake@melvin.net |
This is the book. If you want to understand algorithms, read Knuth's masterpiece. These books are a pleasure to read: his wit, clarity and understanding are unparalleled. I highly recommend all three volumes (and the fourth one, when it is finished).
The series is divided into volumes, with two chapters per volume (so far). This volume contains Chapter 1: Basic Concepts and Chapter 2: Information Structures.
In the first chapter, Knuth introduces mathematical tools that are used constantly in the analysis of algorithms. This is pretty intimidating stuff, but Knuth is not one to try and impress his readers with his impenetrable mathematical prose; rather, he is like a guide who takes great delight in pointing out the marvelous sights of these unfamiliar landscapes.
Also in Chapter 1 is the much reviled MIX, a machine-level language for a fictional computer. Undoubtedly, Knuth's decision to use MIX as opposed to a higher level language is the most controversial aspect of this book. However, bear in mind that Knuth began writing this book in 1962---how well would the presentation have fared if the algorithms were presented in FORTRAN or ALGOL? Further, how could he have presented low-level concepts like subroutine linkage in a higher-level language? Some argue that Knuth should rewrite the books to use C instead of assembly; to them I say: How many people are really, truly conversant in C anymore? People use C++, Java, C#, VisualBasic, etc., not C.
Learning machine-level language has its own benefits: someone has to design compilers, virtual machines, operating systems and computers; at a minimum, those people must known machine-level language. People still program embedded computers, which sometimes means using a machine-level language. I firmly believe that learning machine-level language is important in and of itself.
Knuth made the right decision to use MIX. The best defense of MIX is Knuth's own, in the introduction. Still, if you don't want to learn MIX, all algorithms are clearly presented in English.
The second Chapter is an introduction to what we would nowadays call "Data Structures". Basic structures like arrays and lists prove themselves to be deceptively deep. Even more interesting is his treatment of trees, which are the absolute most useful data structures in the whole of computer science. Modern, high-level languages supply their own data structures (Java's collections, STL, etc.). These implementations are wonderful to have around---I use them myself---but they are one-size-fits-all. For the most part, they do "fit", but when they don't, we need to make our own. In this case, Knuth is there with the most clear, in-depth and comprehensive treatment I have seen of the topic.
In short, I can't recommend Knuth highly enough, but you may want to wait for the fourth edition to come out (around 2010). If you do wait, get a copy from your local university library and spend some time with the absolute classic book on algorithms. |
| |
International Available
