Softpanorama 

Contents  Bulletin  Scripting in shell and Perl  Network troubleshooting  History  Humor 
Introductory  Sorting and searching  
C++ based books  C  C++  OS internals  
OS_related algorithms  Compression 
Compilerrelated /Program Graphs 
Graphs  Random Findings  Etc 
"Great algorithms are the poetry of computer science,
Open Source is just a sometimes wellwritten prose";

The choice of the first book for a serious student is easy  it should be TAOCP by Knuth. I also have great respect for R.E. Tarjan, but IMHO nobody can surpass Donald Knuth in this field. Second book should probably be more language oriented (C oriented, if this course uses C). God forbid to get a toxic cocktail of algorithms and OO programming that is sold in many universities ;).
While Knuth writing is way too academic and as such difficult to comprehend, he is a honest broker and has the IQ to deliver the "meat" for the topic. More dangerous situation arise when the author is trying to make simple things complex and complex incomprehensible. Example of such an approach can be found in a book C++: An Introduction to Data Structures by Larry R. Nyhoff (see my review below). It so overloaded with OO that the key idea of algorithms are lost in OO fog. The main reason here has nothing to do with computer science. It's plain vanilla fashion (plus the desire to "make money fast"). Books by this class of authors are as susceptible for fashion as woman hemline.
This situation actually means that other then TAOCP by Knuth (which is definitely difficult to read) there are very few books on algorithms and data structures for working programmers. A good book is very difficult to find. Most books on the subject were written by the university instructors, so presentation is somewhat superficial, the reality is somewhat distorted and fashion rules...
That means that in many cases content is inadequate for the professional programming. Sometimes they describe algorithms and structures that are mathematically interesting, but impractical. Good authors like Donald Knuth does not trick you like some other authors into believing that you can program algorithm, if you understand how it works. Often there are subtle problems here and there and efficient programming of a particular algorithms requires deep practical experience (or research) and in good textbooks those areas are highlighted and explained.
Many academic authors are unable correctly program even simple algorithms like Bubblesort, but will overload you with unnecessary formalisms up to the ears. The ability to think algorithmically is an adequate foundation for writing a program, but just a foundation. In reality one need to know "nuts and bolts" of the computer and the programming language used (see assembler and C books pages) as well. That's where Knuth shines, and what many academic authors lack. One example of a second rate books on the topic are Robert Sedgewick books.

Algorithms is a difficult field and good comprehension of complex algorithms cannot be achieved without a lot of hard work. Some books gives you a false feeling of mastery of a particular area (for example sorting) by discussion two or three algorithms without mentioning their limitations and tradeoffs involved. For example in sorting large sets the dominant part of the total time might be consumed by not only by comparisons, but by coping of items from virtual memory pages that were replaced. For a very small sets (let's say below 64) factors like overall complexity of the algorithm and the number of operations on each iteration might be more important then the number of comparisons. Also if chances that the set is already nearly sorted are high, that can change the real life behavior of many algorithms
For example often shellsort can be more efficient than Quicksort on some sets and the insertion sort can be faster than shellsort on almost sorted sets of data. With cheap memory Mergesort is usually as good or better as Quicksort, this favorite of academic authors. Similar complex tradeoffs exists in search. Binary or Fibonacci search can be faster for large sets, but if set is small adaptive search and static perfect hashing functions can be even faster.
It is important to understand that if you search the same item again and again heuristic linear search (that starts with the last found item or move the last found item to the top of the list) can be the fastest. For example, in case of compiler often after scanning a particular identifier by lexical analyzer we need to search it again after one or two tokens like in case of statement i=i+1 (as Donald Knuth had shown the overwhelming majority of assignment statements in real programs has simple forms like a=a op b), so just remembering the last identifier searched (or some small cache of them) can give us a significant advantage over blind search of the whole table by the most efficient method possible. Those subtle questions of programming of algorithms can only be learned via experiments and experience.
IMHO, generally students should avoid books that emphasize correctness proofs  such an emphasis usually is a definitive sign of a weak book. Avoid ayatollah of correctness, if you can ;). It's much much better to read How to Solve It, and than all this verificationrelated noise.
C is preferable to C++ and Java for the algorithms course. OOP languages including C++ and Java is a mixed blessing as they conceal the "kitchen". Even STL should be used with moderation ;). Inheritance has almost no relevance to the algorithms field, so IMHO any book about algorithms that discusses inheritance at length is suspect ;). We should not mix eternal things with just fashionable.
The most dangerous situation arise when the author or teacher does not understand real issues and instead of making complex things simple make simple things complex just for the fun of it because he/she is teaching this junk tenth times and, at last, learned the ropes (it's a kind of a sadistic attitude :). Overexposure to OOP in algorithmsrelated course mixes apples with oranges, and I prefer apples and hate oranges. It might be that combination of scripting languages and C or other compiled languages is a better paradigm than overhyped compilercompiler approach used in OO languages.
As a teacher I believe that the best language for studying algorithms and data structures still is assembler. Contrary to popular wisdom, it is simpler to understand complex data structures using assembler than C or other high level language because data representation in assembler is crystal clear and there is no intermediates between you and machine. I can only site here the opinion of Donald Knuth. In his description of MMIX he wrote (italics are mine):
Many readers are no doubt thinking, "Why does Knuth replace MIX by another machine instead of just sticking to a highlevel programming language? Hardly anybody uses assemblers these days.''
Such people are entitled to their opinions, and they need not bother reading the machinelanguage parts of my books. But the reasons for machine language that I gave in the preface to Volume 1, written in the early 1960s, remain valid today:
 One of the principal goals of my books is to show how highlevel constructions are actually implemented in machines, not simply to show how they are applied. I explain coroutine linkage, inputoutput buffering, random number generation, highprecision arithmetic, radix conversion, packing of data, combinatorial searching, recursion, etc., from the ground up.
 The programs needed in my books are generally so short that their main points can be grasped easily.
 People who are more than casually interested in computers should have at least some idea of what the underlying hardware is like. Otherwise the programs they write will be pretty weird.
 Machine language is necessary in any case, as output of many of the software programs I describe.
 Expressing basic methods like algorithms for sorting and searching in machine language makes it possible to make meaningful studies of the effects of cache and RAM size and other hardware characteristics (memory speed, pipelining, multiple issue, lookaside buffers, the size of cachelines, etc.) when comparing different schemes.
Moreover, if I did use a highlevel language, what language should it be? In the 1960s I would probably have chosen Algol W; in the 1970s, I would then have had to rewrite my books using Pascal; in the 1980s, I would surely have changed everything to C; in the 1990s, I would have had to switch to C++ and then probably to Java. In the 2000s, yet another language will no doubt be de rigueur. I cannot afford the time to rewrite my books as languages go in and out of fashion; languages aren't the point of my books, the point is rather what you can do in your favorite language. My books focus on timeless truths.
Therefore I will continue to use English as the highlevel language in TAOCP, and I will continue to use a lowlevel language to indicate how machines actually compute. Readers who only want to see algorithms that are already packaged in a plugin way, using a trendy language, should buy other people's books.
The good news is that programming for RISC machines is pleasant and simple, when the RISC machine has a nice clean design...
I think that the algorithms are the quintessence of open source programming. It's really unfortunate that the concept of open source programming is often used in cultstyle fashion and is pushed as panacea as if open source code without decent algorithms means anything...
NOTE: Other sections of this site that might be interesting are C books, OS related algorithms, Compiler books, Open Source Pioneers/Donald Knuth.
Dr. Nikolai Bezroukov
You can use Honor System to make a contribution, supporting this site 
The best introductory book for Data Structures, November 14, 1999
This book does an excellent job of introducing the mechanics of Data structures. A very useful book to refresh one's knowledge about data structures and get a rigorous insight in the subject in preparation for advanced studies in the area of Data Structures.
Reviewer: An Amazon.com Customer Good book for an introductory University course in Data Structures. This book has been successfully used (and is still being used) as a standard textbook in an intro course in Data Structures at UT Austin
Prerequisites: At least 1 introductory programming course in any high level language (preferably C++). A decent knowledge of C++. (no need of OOP knowledge). Reader should be prepared to seriously study this book.
This is a full blown ACADEMIC book, not a tutorial
Good book..., January 27, 2003
This book is very well written. The language is very clear, but the topic is rather dense. You need to read, then think, then read again.
Reviewer: A reader from Chicago, IL Many of the examples in the book are given in Pseudocode. I like that. It makes it easy to follow the logic of the author and figure out how to code it yourself. It doesn't "give" you the answers.
The Section on recursion is basic, but good (think standard "Hanoi Towers"). The section on Algorithm Efficiency and Sorting is very well done...
Overall, I have not looked at too many of these books, so don't necessarily take my review as authoritative. All I can say is that the language and presentation of the topics in this book is very clear and understandable...
Excellent Primer on Data Structures, November 11, 2000
I used this book for CPS 272 at Washtenaw Community College and found it very clear. The explanations are thorough and very understandable, and the example code is the clearest code I have ever seen (is this really C++?!). When I transfered to the University of Michigan, I used "Data Structures, Algorithms, and Applications in C++" by Sartjai Sahni for EECS 380, which I wouldn't recommend to anyone. I found myself constantly referring back to Carrano's text. The only thing I have against it is that it doesn't cover algorithm efficiency and bigO notation well enough, but I have no hesitation giving it 5 stars. Get you started on good programming style, March 2, 2000
Reviewer: David Kaye from Ann Arbor, MI
I would not recommend this book to beginners but this book is definately a good book for people with some programming foundation. Advanced data structures are well explained. We are using this book at school and I am totally comfortable with it. I can actually accomplish something that I've never been able to. On thing that reader need to understand is this book is mostly concentrated on advanced data structure concept. Some reviewers said that it is mostly psudocode and it is true because the author is trying to let you understand the concept of advanced programming. Anyway, this book is a good step stone for you to reach highest programming concepts and skills.
Reviewer: Zhang Xuejin (see more about me) from Lincoln, NE USA
Average Customer Review: ** Hardcover  700 pages 1 edition (January 21, 1999)
Prentice Hall; ISBN: 0023887257 ; Dimensions (in inches): 1.60 x 9.58 x 7.23
Amazon Price: $73.00This very expensive book is used in many colleges for Advanced Object Oriented programming course as well as Data Structures course. If you use it in Advanced Object Oriented Programming course you need to cry and run or run and cry ;). The individual features of C++ discussed in the book are not only complex by themselves, but when put together in a program they interact in highly nonintuitive ways. The author discuss each of the features very briefly and as an isolated entity, giving the readers the illusion of understanding but avoiding discussing any nontrivial issues that arise in practice and typical mistakes. But when they try to program using the book, they're in for a painful surprise. This book is more about STL then data structures and depending on your background your mileage may vary.
In the first three chapters the author delves into C++ arcana and I suspect that a student with just one (and semiforgotten) course of C++ will be unable to understand this material no matter what. Examples are sketchy and often require some work to make them run. First two or three l labs are especially weak and does not help to refresh C++ for those who did not take C++ cause in the prev semester. The level of understanding of C++ required for those labs is somewhat out of touch with the college reality when students that take this class barely can program in C++ Later labs are OK and labs on strings, vectors and inheritance are actually good. IMHO first two labs are simply unsuitable for most students after a year of C++ experience. And to add insult to injury none of the tricky areas covered in the labs are explained well in the book.
Chapter 1 discusses software development. Extremely weak and superficial treatment of a pretty complex topic. It's clear that the author does not understands the subject in depth and the chapter is completely detached from reality. Any student would be better off reading the "Elements of the Program Style" instead as for programming style and Rapid Development for software development issues. This chapter provides no help of dealing with real problems arising in C++ development. The waterfall model of software development is introduced without even mentioning alternatives, for example "rapid prototyping" approach. The "official" list of software development stages provided in a book is highly misleading. In practice, the phases are intermixed and the process in iterative  often you need to return from coding to specification after discovering that the approach chosen does not work or that there is a better way to specify the task that leads to a cleaner and/or simpler solution.
Chapter 2 discusses relationship between data structures and abstract data types. Discussion of the primitive C++ data types contains some information that is more appropriate for the assembler class (like the way floating representation stores mantissa ). After that the author discusses arrays. Sparse arrays problem and the storage of multidimensional arrays are completely ignored. Some author claims are suspect. For example of p.52 we read:
"One of the principles of object oriented programming is that an object should be selfcontained, which means that it should carry within itself all the information necessary to describe and operate on it. Arrays violate this principle. in particular they carry neither their size nor their capacity within them..."
... " we must pass to Print() not only the array to be displayed but also its size, and this is not consistent with the aims of the objectoriented programming" (italics belongs to the Larry Nyhoff  NNB).
It's because such nonsense I hate the books that mix OOP with data structures :). It looks like the author does not understand that C++ implementation of arrays is not universal and in some old procedural languages like PL/1 the size of the array is passed as a hidden parameter and can be retrieved using buildn function ;). Same is true for scripting languages like Perl. In those languages arrays are pretty much selfcontained. Then the author tries to explain structures and fail to provide any reasonable treatment of the reallife aspects of this topic. For example is next to impossible to understand how unions work from the text and I highly recommend to get a different textbook for the topic At the end of the chapter the author extols the virtue of OOP in comparison with the procedure oriented programming although is if we talk about algorithms and data structures, then OO approach is highly suspect and might represents a contemporary religious aberration that will not survive the test of the time.
In Chapter 3 along with explanation of C++ class construct the author managed to discusses strings (without much details. A simple editor listing is provided, a definite plus for the chapter), but then for some reason data encryption algorithms (DES and RSA), and, to ensure that the student completely lost interest, the subject pattern matching is added to the mix :).
After that the book changes the topic and became more introduction of STL library that a data structure course. As an introduction to STL the book makes sense but as an introduction to data structures probably not. Chapter four discusses stacks. Chapter 5 queues. Chapter 6 is devoted to Templates and Standard containers. Chapter 7 is about ADTs. Chapters 8 and 9 discuss lists. Chapter 10 discusses binary trees. Chapter 11 discusses sorting. Chapter 12 tries to link OOP and abstract data types. Chapter 13 is devoted to trees. Chapter 14 discusses Graphs and Digraphs.
You cannot compare this text to Knuth were you really feel the class of author even if you do not understand half of the material (the respect that might help to return to the subject later in one's professional career.) Here a typical student probably will never understand twothirds of the material because data structures are obscured by objectoriented arcana. And he/she will not receive anything in return other then strong desire not have anything in common with this subject for the rest of your professional life :).
table of contentsPaperback: 368 pages ; Dimensions (in inches): 0.78 x 9.18 x 7.72
Publisher: AddisonWesley Pub Co; 3rd edition (August 16, 2001)
ISBN: 0201316633
Hardcover: 496 pages ; Dimensions (in inches): 1.15 x 9.55 x 7.33
Publisher: Springer Verlag; (June 1999)
ISBN: 0387986324
Hardcover (June 1997)
Cambridge Univ Pr (Short); ISBN: 0521585198wiredweird (from USA)
What it says, it says best., August 17, 2003Srinivas Aluru (Iowa State University, USA)If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.
No, there isn't any real source code here. That should not be a problem  this book aims above the cut&paste programmer. The book is meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.
String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other nondeterministic optimizations, and probabilitybased techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.
By the way, don't let the biological orientation put you off. DNA analysis is just one place where stringmatching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.
The one book you need to study string algorithms May 22, 2000devolver@iastate.edu (see more about me) from IowaThis is a great book for anyone who wants to understand string algorithms, pattern matching or get a rigorous algorithmic introduction to computational biology. Comprehensive textbook covering many useful algorithms. Very well written.
The String Algorithm Bible? May 15, 2000Peter A. Friend (from Los Angeles, California)A wonderful book that covers many of the basic algorithms (Z, BoyerMoore, KnuthMorrisPratt) and then moves on to a wonderful discussion of suffix trees and inexact matching. This is an essential book on the topic, but definitely targeting programmers; if you're not a programmer, this book could be a challenge. Of course, if you're not a programmer, this book may hold little interest to you.
One of the best books on string searching and matching June 15, 1998When you try to teach yourself a subject, you end up buying large numbers of books so that all of the little gaps are filled. Unfortunately, I didn't find this book until AFTER I spent a fortune on others. Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math. By far, the best book on the subject I have found, especially if you are "into" genetics
Birkhauser (Architectural); ISBN: 0817641769 ; Dimensions (in inches): 0.69 x 9.51 x 6.41
Hardcover  494 pages 1 edition (August 12, 1996)
Prentice Hall; ISBN: 0131907522 ; Dimensions (in inches): 0.98 x 9.55 x 7.27A reader from
San Diego, CA Above average but recommend others, December 5, 1999
I used this textbook to teach Data Structures and Algorithms at the sophomorejunior level to a class of 100 students. My primary focus is to teach the design and use of DS&A with a secondary focus on implementation in a specific language (Java in this case). From this point of view: Part I is excellent. Part II is above average. The discussion of trees is average with an implicitly narrow view of applications. Part III on sorting and searching is average with the exception of the horrible discussion of benchmarking in 8.8. The data are unqualified and misleading (compiled and interpreted runtimes are compared as equals!). The discussion of hashing and BTrees is poorly organized and narrow. Parts III and IV are oriented towards Java implementation. As such, there is no discussion of the limitations of actually using recursion in an implementation nor the efficient use of objectoriented structures in cachebased architectures. For a better discussion of DS&A, many of my less experienced students found relief in Robert Lafore's book (ISBN 1571690956) and the more advanced students consulted Weiss's text (ISBN 0201357542). For the following term I will try Cormen, Leiserson, and Rivest's classic Introduction to Algorithms (ISBN 0070131430) which uses pseudocode and Lafore's book as a required supplement.
Paperback  256 pages 1 edition (September 27, 1996)
John Wiley & Sons; ISBN: 0471149667 ; Dimensions (in inches): 0.65 x 9.28 x 7.54
Paperback  239 pages (August 1999)
Morgan Kaufmann Publishers; ISBN: 0127887741 ; Dimensions (in inches): 0.72 x 9.26 x 7.44
Hardcover 2nd edition (June 2000)
Brooks/Cole Pub Co; ISBN: 0534375979
Hardcover  1018 pages (February 2000)
Cambridge Univ Pr (Short); ISBN: 0521563291 ; Dimensions (in inches): 2.23 x 10.01 x 7.95
Hardcover  1296 pages (October 1999)CRC Press; ISBN: 0849326494 ; Dimensions (in inches): 2.51 x 10.30 x 7.37
1 Algorithm Design and Analysis Techniques
Edward M. Reingold
2 Searching Ricardo BaezaYates
Patricio V. Poblete
3 Sorting and Order Statistics
Vladimir EstivillCastro
4 Basic Data Structures Roberto Tamassia
Bryan Cantrill
5 Topics in Data Structures
Giuseppe F. Italiano Rajeev Raman
6 Basic Graph Algorithms Samir Khuller
Balaji Raghavachari
7 Advanced Combinatorial Algorithms Samir Khuller
Balaji Raghavachari
8 Dynamic Graph Algorithms
David Eppstein Zvi Galil
Giuseppe F. Italiano
9 Graph Drawing Algorithms Peter Eades
Petra Mutzel
10 Online Algorithms: Competitive Analysis and Beyond
Steven Phillips
Jeffery Westbrook
11 Pattern Matching in Strings
Maxime Crochemore
Christophe Hancart
12 Text Data Compression Algorithms
Maxime Crochemore
Thiery Lecroq
13 General Pattern Matching Alberto Apostolico
14 Average Case Analysis of Algorithms Wojciech Szpankowski
15 Randomized Algorithms
Rajeev Motwani Prabhakar Raghavan
16 Algebraic Algorithms
Angel Diaz
Ioannis Z. Emiris Erich Kaltofen
Victor Y. Pan
17 Applications of FFT
Ioannis Z. Emiris
Victor Y. Pan
18 Multidimensional Data Structures Hanan Samet
19 Computational Geometry I
D. T. Lee
20 Computational Geometry II
D. T. Lee
21 Robot Algorithms
Dan Halperin
Lydia Kavraki
JeanClaude Latombe 22 Vision and Image Processing Algorithms
Concettina Guerra
23 VLSI Layout Algorithms
Andrea S. LaPaugh
24 Basic Notions in Computational Complexity Tao Jiang
Ming Bala Ravikumar
25 Formal Grammars and Languages Tao Jiang
Ming Bala Ravikumar
Kenneth W. Regan
26 Computability Tao Jiang
Ming Bala Ravikumar
Kenneth W. Regan
27 Complexity Classes Eric Allender
Michael C. Loui Kenneth W. Regan
28 Reducibility and Completeness Eric Allender
Michael C. Loui Kenneth W. Regan
29 Other Complexity Classes and Measures Eric Allender
Michael C. Loui Kenneth W. Regan
30 Computational Learning Theory Sally A. Goldman
31 Linear Programming
Vijay Chandru
M.R. Rao
32 Integer Programming
Vijay Chandru
M.R. Rao
33 Convex Optimization
Stephen A. Vavasis
34 Approximation Algorithms Philip N. Klein
Neal E. Young
35 Scheduling Algorithms
David Karger
Cliff Stein Joel Wein
36 Artificial Intelligence Search Algorithms Richard E. Korf
37 Simulated Annealing Techniques Albert Y. Zomaya
Rick Kazman
38 Cryptographic Foundations
Yvo Desmedt
39 Encryption Schemes
Yvo Desmedt
40 Crypto Topics and Applications I Jennifer Seberry
Chris Charnes Josef Pieprzyk
Rei SafaviNaini
41 Crypto Topics and Applications II Jennifer Seberry
Chris Charnes Josef Pieprzyk
Rei SafaviNaini
42 Cryptanalysis Samuel S. Wagstaff, Jr.
43 Pseudorandom Sequences and Stream Ciphers Andrew Klapper
44 Electronic Cash Stefan Brands
45 Parallel Computation Raymond Greenlaw
H. James Hoover
46 Algorithmic Techniques for Networks of Processors
Russ Miller Quentin F. Stout
47 Parallel Algorithms Guy E. Blelloch
Bruce M. Maggs
48 Distributed Computing: A Glimmer of a Theory
Eli Gafni
Index
Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236A reader from USA
Very well written Data Structures text! May 28, 1999This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier
Textbook Binding  192 pages 1 edition (February 8, 1995)
Prentice Hall; ISBN: 0134335589 ; Dimensions (in inches): 0.37 x 9.22 x 6.97
Textbook Binding  464 pages (October 1997)
AddisonWesley Pub Co; ISBN: 0201314517 ; Dimensions (in inches): 0.87 x 9.20 x 7.51George Perantatos (Atlanta, GA)
An excellent introduction into algorithmic concepts. April 13, 1999As a teaching assistant for CS1501, Introduction to Computing at Georgia Tech, a successful brainchild of Dr. Shackelford's, I have used this book from both a student's and a teacher's standpoint, and thus feel adept at highlighting its successes.
This book provides a concise, clear review of the basic concepts of algorithmic thought and its subsequent expression and application. After a brief review of the history of computing, the reader is launched into an everdeepening understanding of basic CS tools from a problemsolving point of view.
Topics of interest include dynamic data structures (BST's, linked lists), array storage, stacks + queues, objectoriented programming, precedence and dependence, and a brief sojourn into higherlevel theory concepts.
The highlight, and in my opinion success, of this book is the fact that no "real" programming language is used to notate any examples. Rather, Dr. Shackelford, along with other TA's of recent past, devised a pseudolanguage which encapsulates many elements of previous educational languages (such as Pascal); naturally, this language is not vulnerable to obsolescence. Also, since this language can not be practically compiled, the reader is forced to trace through examples on his or her own, building his or her skills in mentally evaluating algorithms.
This book, once limited to the Georgia Tech CS curriculum, has now expanded to many other colleges and universities, and more institutions are becoming interested as the months progress. This text is a musthave for any individual interested in getting a substantial taste in algorithms and computing.
Hardcover  688 pages 3 edition (November 15, 1999)
AddisonWesley Pub Co; ISBN: 0201612445 ; Dimensions (in inches): 1.26 x 9.51 x 7.80
Other Editions: Hardcover(Sara Baase also wrote Gift of Fire, A: Social, Legal, and Ethical Issues in Computing)
This is the third edition (the first was in 1988). Here is the table of contents. Some interesting stuff covered:Great Ideas in Computer Science A Gentle Introduction by Alan W. Biermann, Alan W. Bierman
The Advent of the Algorithm The Idea that Rules the WorldPaperback  568 pages 2nd edition (April 1997)
MIT Pr; ISBN: 0262522233 ; Dimensions (in inches): 1.26 x 8.97 x 8.02
**** The Algorithm Design Manual ~ Book contains CD with full etext. There is a WEB site Steven S. Skiena, Steve Skiena / Hardcover / Published 1997Amazon price: $19.60
Hardcover  368 pages 1st edition (March 6, 2000)
Harcourt Brace; ISBN: 0151003386 ; Dimensions (in inches): 1.18 x 9.30 x 6.25
Amazon.com Sales Rank: 990
Avg. Customer Review:
Number of Reviews: 3
Amazon price: $59.95
Web site: The Stony Brook Algorithm Repository This book comes with a substantial electronic supplement, a ISO9660 compatible, multiplatform CDROM, which can be viewed using Netscape, Microsoft Explorer, or any other WWW browser. This CDROM contains:(1) A complete hypertext version of the full printed book. Indeed, the extensive crossreferences within the text are best followed using the hypertext version.
(2) The source code and URLs for all cited implementations, mirroring the Algorithm Repository WWW site. Programs in C, C++, Fortran, and Pascal are included, providing an average of four different implementation
(3) Over thirty hours of audio lectures on the design and analysis of algorithms are provided, all keyed to online lecture notes. Following these lectures provides another approach to learning algorithm design techniques. Listening to all the audio is analogous to taking a onesemester college course on algorithms!
Algorithms in C++: Fundamentals, Data Structures, Sorting, Searching Robert Sedgewick / Paperback / Published 1999
Amazon price: $39.95
C++: An Introduction to Data Structures. (C and C++ are two distinct programming languages.) ~ Usually ships in 24 hours Larry R. Nyhoff / Hardcover / Published 1999
Amazon price: $65.75
Graph Drawing : Algorithms for the Visualization of Graphs ~ Usually ships in 24 hours Giusepp Di Battista, Peter Eades, Roberto Tamassia, and Ioannis G. Tollis / Hardcover, 432 p. / Published by PrenticeHall, 1998/ ISBN 0133016153
Amazon price: $66.00 Positively reviewed at ERCB DDJ Programmer's Bookshelf June 1999???? Mastering Algorithms With Perl Jon Orwant, et al / Paperback / Published 1999
Amazon price: $27.96 ~ You Save: $6.99 (20%)A reader from Austin, TX USA
5. Selection and Adversary Arguments.
Introduction.
Finding Max and Min.
Finding the SecondLargest Key.
The Selection Problem.
A Lower Bound for Finding the Median.
Designing Against an Adversary.
6. Dynamic Sets and Searching.
Introduction.
Array Doubling.
Amortized Time Analysis.
RedBlack Trees.
Hashing.
Dynamic Equivalence Relations and UnionFind Programs.
Priority Queues with a Decrease Key Operation.
7. Graphs and Graph Traversals.
Introduction.
Definitions and Representations.
Traversing Graphs.
Strongly Connected Components of a Directed Graph.
DepthFirst Search on Undirected Graphs.
Biconnected Components of an Undirected Graph.
8. Graph Optimization Problems and Greedy Algorithms.
Introduction.
Prim's Minimum Spanning Tree Algorithm.
SingleSource Shortest Paths.
Kruskal's Minimum Spanning Tree Algorithm.9. Transitive Closure, AllPairs Shortest Paths.
Introduction
The Transitive Closure of a Binary Relation.
Warshall's Algorithm for Transitive Closure.
AllPairs Shortest Paths in Graphs.
Computing Transitive Closure by Matrix Operations.
Multiplying Bit MatricesKronrod's Algorithm.
10. Dynamic Programming.
Introduction.
Subproblem Graphs and Their Traversal
Multiplying a Sequence of Matrices.
Constructing Optimal Binary Search Trees.
Separating Sequences of Words into Lines.
Developing a Dynamic Programming Algorithm.
11. String Matching.
Introduction.
A Straightforward Solution.
The KnuthMorrisPratt Algorithm.
The BoyerMoore Algorithm.
Approximate String Matching.
12. Polynomials and Matrices.
Introduction.
Evaluating Polynomial Functions.
Vector and Matrix Multiplication.
The Fast Fourier Transform and Convolution.OK book. Bad subject matter. February 4, 2000A readerUsing perl to implement data structures and algorithms is kind of a laughable concept. Perl was designed specifically so that users wouldn't have to deal with this sort of thing. Algorithms written in perl are much less portable than algorthms written in a more low level language, and perl's built in data types are so powerful that they make the construction of user defined types unnecessary.
Not to mention the fact that perl does so much behind your back that unless you go rooting through source code it is impossible to get truly accurate time complexity analysis of algorithms implemented in perl.
If you are looking for a good algorithm book, check out Corman's Introduction to Algorithms. If you are looking for a good perl book, check out Programming Perl. If you are looking for a book that will tell you how to do a bunch of weird stuff with perl, check out Conway's Object Oriented Perl. But perl and hardcore algorithm study have never mixed, and god knows they shouldn't.
more perl than algorithms ... December 18, 1999
After reading rave reviews about this book all over the net, I decided to check it out. I found it a bit disappointing for several reasons. First, there appear to be type setting errors that are distracting. For example, there are sections with example code with text that follows, only the text that follows appears to be introducing the next code snippet, but is actually describing the snippet above (off by 1 error?) Indeed the final code snippet in a section has no following explanatory text.
This is only a problem early on though because as the book progresses, the authors stop describing the code examples! In fact, I found myself trying to figure out what the text was doing in the chapters since all of the concepts were explained in code (without full explanations in the text). <this is a minor exaggeration>
In addition, I found the unrelated annecdotes and allusions and obscure literary quotes a further distraction. I'm sure there is a certain academic audience that would appreciate this, but I hate having to look up words only to find out I didn't really need to look them up ;).
Some other things I disliked were the absence of hashes in the data structures section (perl has built in hashes, so you'd think a discussion on what a hash is, and hashing algorithms would be included in a perl algorithms book), and the description of algorithm analysis was too short.
On the up side, the sorting and searching sections are very thorough (the perl code implementing them, not the text explaining the code), as are the other sections. If its perl your after, this book has some of the best perl code in print (save for Joseph Hall's "Effective Perl").
In summary, if you already understand these topics, then this book will show you some excellent perl code to implement them. If you do not understand the data structures and algorithms already, I don't think this book is going to make them crystal clear (though the authors are good about referring the reader to other sources).
4 camels for the high quality perl code and thoroughness, but it could have been 5 if the authors followed through with the type of supporting text that Hall did in EP.
See recommended for better choices
Average Customer Review: ** Hardcover  700 pages 1 edition (January 21, 1999)
Prentice Hall; ISBN: 0023887257 ; Dimensions (in inches): 1.60 x 9.58 x 7.23
Amazon Price: $73.00This very expensive book is used in many colleges for Advanced Object Oriented programming course as well as Data Structures course. If you use it in Advanced Object Oriented Programming course you need to cry and run or run and cry ;). The individual features of C++ discussed in the book are not only complex by themselves, but when put together in a program they interact in highly nonintuitive ways. The author discuss each of the features very briefly and as an isolated entity, giving the readers the illusion of understanding but avoiding discussing any nontrivial issues that arise in practice and typical mistakes. But when they try to program using the book, they're in for a painful surprise. This book is more about STL then data structures and depending on your background your mileage may vary.
In the first three chapters the author delves into C++ arcana and I suspect that a student with just one (and semiforgotten) course of C++ will be unable to understand this material no matter what. Examples are sketchy and often require some work to make them run. First two or three l labs are especially weak and does not help to refresh C++ for those who did not take C++ cause in the prev semester. The level of understanding of C++ required for those labs is somewhat out of touch with the college reality when students that take this class barely can program in C++ Later labs are OK and labs on strings, vectors and inheritance are actually good. IMHO first two labs are simply unsuitable for most students after a year of C++ experience. And to add insult to injury none of the tricky areas covered in the labs are explained well in the book.
Chapter 1 discusses software development. Extremely weak and superficial treatment of a pretty complex topic. It's clear that the author does not understands the subject in depth and the chapter is completely detached from reality. Any student would be better off reading the "Elements of the Program Style" instead as for programming style and Rapid Development for software development issues. This chapter provides no help of dealing with real problems arising in C++ development. The waterfall model of software development is introduced without even mentioning alternatives, for example "rapid prototyping" approach. The "official" list of software development stages provided in a book is highly misleading. In practice, the phases are intermixed and the process in iterative  often you need to return from coding to specification after discovering that the approach chosen does not work or that there is a better way to specify the task that leads to a cleaner and/or simpler solution.
Chapter 2 discusses relationship between data structures and abstract data types. Discussion of the primitive C++ data types contains some information that is more appropriate for the assembler class (like the way floating representation stores mantissa ). After that the author discusses arrays. Sparse arrays problem and the storage of multidimensional arrays are completely ignored. Some author claims are suspect. For example of p.52 we read:
"One of the principles of object oriented programming is that an object should be selfcontained, which means that it should carry within itself all the information necessary to describe and operate on it. Arrays violate this principle. in particular they carry neither their size nor their capacity within them..."
... " we must pass to Print() not only the array to be displayed but also its size, and this is not consistent with the aims of the objectoriented programming" (italics belongs to the Larry Nyhoff  NNB).
It's because such nonsense I hate the books that mix OOP with data structures :). It looks like the author does not understand that C++ implementation of arrays is not universal and in some old procedural languages like PL/1 the size of the array is passed as a hidden parameter and can be retrieved using buildn function ;). Same is true for scripting languages like Perl. In those languages arrays are pretty much selfcontained. Then the author tries to explain structures and fail to provide any reasonable treatment of the reallife aspects of this topic. For example is next to impossible to understand how unions work from the text and I highly recommend to get a different textbook for the topic At the end of the chapter the author extols the virtue of OOP in comparison with the procedure oriented programming although is if we talk about algorithms and data structures, then OO approach is highly suspect and might represents a contemporary religious aberration that will not survive the test of the time.
In Chapter 3 along with explanation of C++ class construct the author managed to discusses strings (without much details. A simple editor listing is provided, a definite plus for the chapter), but then for some reason data encryption algorithms (DES and RSA), and, to ensure that the student completely lost interest, the subject pattern matching is added to the mix :).
After that the book changes the topic and became more introduction of STL library that a data structure course. As an introduction to STL the book makes sense but as an introduction to data structures probably not. Chapter four discusses stacks. Chapter 5 queues. Chapter 6 is devoted to Templates and Standard containers. Chapter 7 is about ADTs. Chapters 8 and 9 discuss lists. Chapter 10 discusses binary trees. Chapter 11 discusses sorting. Chapter 12 tries to link OOP and abstract data types. Chapter 13 is devoted to trees. Chapter 14 discusses Graphs and Digraphs.
You cannot compare this text to Knuth were you really feel the class of author even if you do not understand half of the material (the respect that might help to return to the subject later in one's professional career.) Here a typical student probably will never understand twothirds of the material because data structures are obscured by objectoriented arcana. And he/she will not receive anything in return other then strong desire not have anything in common with this subject for the rest of your professional life :).
Less than helpful, May 13, 2000
Reviewer: liz mccraven (see more about me) from New JerseyI used this book as a student in an online version of a Data Structures class. None of us liked this book. The examples are vague and some of the exercises are misleading. I found the organization of the book to be confusing as well. Not good for learning Data Structures on your own.Not for the faint of heart, January 31, 2000
Reviewer: Jim Hare (see more about me) from St Louis, MOThis book, while perhaps suitable for a more agressive Data Structures course. Was unsuitable for most students in my college Data Structures class after a year of C++ experience. The code presented in the text is very skeletal, with far too many "left as an exercise to the reader" for my taste.
Springer Verlag; ISBN: 0387948600 ; Dimensions (in inches): 1.19 x 9.51 x 7.25
Amazon.com Sales Rank: 19,160Avg. Customer Review: *****
Number of Reviews: 8
Web site: The Stony Brook Algorithm Repository This book comes with CDROM which contains:(1) A complete hypertext version of the full printed book. Indeed, the extensive crossreferences within the text are best followed using the hypertext version.
(2) The source code and URLs for all cited implementations, mirroring the Algorithm Repository WWW site. Programs in C, C++, Fortran, and Pascal are included, providing an average of four different implementation
(3) Over thirty hours of audio lectures on the design and analysis of algorithms are provided, all keyed to online lecture notes. Following these lectures provides another approach to learning algorithm design techniques. Listening to all the audio is analogous to taking a onesemester college course on algorithms!
The hitchhiker's guide to Algorithms. July 28, 1998A reader from Brussels, Belgium.
The Catalog was my main reason for buying the book. It's an invaluable reference base for people whose boss 'needs an answer by tomorrow'.
+ : The War Stories are fun reading, and do a good job of explaining how theory relates to practice.
 : Restating the obvious at times, while deliberately vague elsewhere.
Net : if you use a greedy heuristic to select your reading, this book probably comes ahead of the pack.
This is a must for programmers June 28, 1999
Antonio Costa (accmdq@mail.esoterica.pt) (see more about me) from Porto, Portugal
This book is very well organized. It really helps identifying and solving problems. Highly recommended.
Includes nine books:
 Data Structures: From Arrays to Priority Queues by Wayne Amsbury
 Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest
 Information Retrieval: Data Structures & Algorithms edited by William B. Frakes and Ricardo BaezaYates
 Fundamentals of Data Structures by Ellis Horowitz and Sartaj Sahni
 Reliable Data Structures in C by Thomas Plum
 Data Structures and Algorithm Analysis in C by Mark Allen Weiss
 Practical Data Structures in C++ by Bryan Flamig
 Data Structures, Algorithms and Program Style Using C by James F. Korsh and Leonard J. Garrett
 Data Structures and Algorithms by Alfred V. Aho, John E. Hopcroft and Jeffrey D. Ullman
Plus more than a dozen articles related to algorithms from Dr. Dobb's Journal!
Paperback  400 pages (August 5, 1999)
O'Reilly & Associates; ISBN: 1565924533
Table of contentsSample Chapters
Examples
Errata
Generally it's seems to be better that Robert Lafore book. Contains a chapter on compression and a chapter on encryption. Very sloppy typesetting  especially of C programs (ugly commentaries that took too much space, etc.). Graph algorithms section is weak. Sorting is not bad, but does not include selection sort (which, in the class of simple sort algorithms, is sometimes better than insertion sort) and Shell sort which simple and underappreciated algorithm that, for example, on almost sorted data beats much more popular (and somewhat more complex) quicksort. Again the book is not bad, but has a lot of weak points typical for the first edition. Here is one negative comment from Amazon that probably explains weak points better:Horrid Title UnLike O'Reilly
A reader from Santa Monica, California September 8, 1999
Terse explanations, poor diagrams, poor coding style, poor writing style, and poor information covered on each topic listed in table of contents with probably the exception being the Huffman algorithms for data compression. The book is out of standard with most of O'Reilly's rich text and exhaustive detail and real world working code blocks and monitor like diagrams, but this book is nothing but fill and a terrible disappointment. The book is listed at Amazon as having 400 pages, not true, do not believe it, the book actually has 600. I suggest for the critism that Sedgwick gets, his Algorithms in C++ Parts 14 is truly the most detailed book on algorithms and data structures there is and it is the best to be a guru software engineer in problem solving and algorithm and data structure mastery. The next book to read that may be better than Sedgewick's is Sartag Sahni's Algorithms, Data Structures, and Applications in C++ by MacGrawHill.
*****Exceptional writing, elegant code, great examples September 13, 1999
A reader from Palo Alto, CA
Mastering Algorithms in C is the most readable algorithms book I've ever encountered. Not only does the author have a tremendous command of English, he has a writing style that is simply a pleasure to read. The author also deserves mention as having one of the cleanest coding styles I've come across. Having taught and worked with computers for over 15 years, I've seen many. It is no easy feat to present the subject of algorithms using real C code in a consistently elegant manner. This book does it wonderfully. Another feature of the book that works exceptionally well is its detailed presentation of interesting (and I emphasize interesting) realworld examples of how various data structures and algorithms in the book are actually applied. I'm a computer science type, so I especially enjoyed the examples about virtual memory managers, lexical analyzers, and packetswitching over the Internet. But the book includes many other examples of more general interest. Students will find all of the examples particularly insightful. Although most of the code in the book does make use of many of the more advanced features of C, an inordinate number of comments have been included which should help even the feeblest of programmer carry on. In addition, there are two great chapters on pointers and recursion. Exceptional writing, elegant code, great examples, not to mention a lot of entertainment value  O'Reilly has another winner here. I highly recommend it.
Table of content Paperback  523 pages Bk&Cd Rom edition (May 1999)
Sams; ISBN: 0672316331 ; Dimensions (in inches): 1.42 x 9.05 x 7.34
Not bad decent introductory book at a reasonable price. Robert Lafore wrote almost a dozen books about C/C++/Object oriented programming, but from what I can see he is not OO fundamentalist. The last kind of books make him a little bit suspect but he authored Assembly Language Primer for the IBM PC and XT, so let's hope that he is not regular objectoriented junk writer ;). The book contains demonstration applets  a novel approach. CD contains DJGPP compiler  a semidecent 32 bit compiler that was ported from GNU C/C++ Unix compilers  does not make much sense now when Borland C 2.0 is available from Borland site.Decent illustrations. I noted flow chart for the Insertion sort which is nice to have. Generally presence of flowcharts can be considered as a sure sign of a realistic nonfundamentalist approach to teaching algorithms and data structures. It's really unfortunate that the book does not have a etext on the CD. Robert Lafore has also authored:
Answers to exercises (at least half of them), please! July 18, 1999
A reader from RTP, NCI have decided that authors that are not willing to provide detailed solutions to at least the oddnumbered exercises are not worth reading. Why? Because first, where is the evidence that they know the answers to the exercises they present? But more importantly, how is the reader supposed to actually learn from the exercises if he can't see at least one possible solution and the rationale for that solution? This is the same reason why the Deitel & Deitel books are unacceptable. This isn't college anymore. Let's have some answers...if we knew how to do all this stuff already, we wouldn't need the book!
Why do people like this book? July 7, 1999
Reviewer: A reader from Princeton University
It is strange to me why some people love this book so much. Admittedly, Sedgewick is very respected in his field and knows a lot about sorting algorithms, but his book is still dissapointing and very frustrating to read for a beginning computer science student. He seldom includes complete code in his examples, and where there is code, there are sometimes errors in the code.
This reviewer took Sedgewick's class at Princeton University where this book was the required text, and not only was the text poor, his lectures were terribly boring. He himself even recognized that there were errors in his book, and so he allowed his students and TA's to submit errors found in the book. At the end of the year, the list of references to mistakes in the book took up more than three pages.
This review is not the result of a student upset about his grade (an A is fine with me), but is rather an attempt to warn students about the potential pitfalls that may be encountered in reading Sedgewick's book. I suppose this could be a great book for an intermediate or advanced CS student who doesn't mind the sparse and sometimes erroneous code or the terse language used to describe fairly complex ideas. Also, there are some parts of the book that are well written and a pleasure to read. However, I would never recommend this book to anyone interested in learning algorithms for this first time without a fair amount of prior programming experience.
If you need to use Java for the course this is a decent book
Mitchell Waite, Robert Lafore
Hardcover  600 pages Bk&Cd Rom edition (April 1998)
Waite Group Pr; ISBN: 1571690956 ; Dimensions (in inches): 1.60 x 9.49 x 8.33This was an excellent nonacademic book on data structures, December 9, 1998
Reviewer: thornkin@hotmail.com from Kirkland, WAThis book is a very accessible text on the subject of data structures and algorithms using Java as the implementation language. I found the book to cover things excellently. The author is very efficient and handles these topics without being either too wordy or not giving enough information. The book approaches the subject from what I would call a nonacademic angle. The coverage of BigO notation is nonmathematicall. The author explains the BigO speed of each data structure or algorithm but does not go into detail about the mathematical basis of such a number. One falling point for some may be the lack of exercizes. I, for one, did not miss these but if you are looking for a book with them, you'll have to look elsewhere. Overall, I highly recommend this book, especially for someone new to the subject. One last point, while the author fails to give any Java implementation for RedBlack trees, this is the only place in the book where he does so. He clearly explains his reasoning for doing as he doesthe subject is quite complicated and the code for it immense. He does, however, give a good theoretical explanation of the subject.
One of the best Data Structures books around, March 31, 2000
Reviewer: wonderrat (see more about me)I am surprised that most instructors haven't banned this book! It is absolutely one of the best data structures references on the market and with answers provided with the enclosed CD, one perfect "cheat book." Virtually all the standard data structures for an introductory DS&A course are included here with a good explanation behind the rationale used in the implementation of the code. Lafore is a good writer and explains things well, unlike certain authors. The book isn't heavy on the mathematics, which is good for programmers who don't want to get involved with theory. The applets which implement the data structures are particularly nice.
As mentioned in a previous review, trees are not covered well in this book, but most introductory books don't cover them well either. I don't expect to see an analysis of AVL or redblack trees in an introductory book (Cormen's text, which is the standard for grad school, doesn't explain trees well either). In fact, only Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest. But for linked lists, stacks,queues, and the like, there are few books that are the equal of this one. Buy the book and you'll pass your DS&A class with flying colors!
Hardcover  560 pages 1 edition (October 1, 1998)
Peachpit Press; ISBN: 0201357542 ; Dimensions (in inches): 0.97 x 9.49 x 7.73
Amazon.com Sales Rank: 18,729
Avg. Customer Review:
Number of Reviews: 5Definitely one to consider, June 8, 1999
Reviewer: A reader fromSeattle, Washington
Definitely one to consider if you're looking for an advanced text on DS&A in Java. Wellwritten, thorough, and ALL the source code is downloadable on Weiss's site www.cs.fiu.edu/~weiss . This is by far my favorite algorithms text, although I expect Sedgewick's "Algorithms in Java, Parts 14" to be comparable when/if it ever is finally published.
Note: I would prefer pseudocode based books, but your mileage may vary.
Richard F. Gilberg, Behrouz A. Forouzan / Hardcover / Published 1998
Usually ships in 24 hours
Average Customer Review: Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236Very well written Data Structures text! May 28, 1999
A reader from USA
This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier
Overated book...
Hardcover  509 pages (March 1991)
AddisonWesley Pub Co; ISBN: 067339736X ; Dimensions (in inches): 1.26 x 9.57 x 6.43
Amazon.com Sales Rank: 369,949
Avg. Customer Review:
Number of Reviews: 4
Table of contents
Too short to be useful for such a volume of material.
Great introduction to the subject, wonderful teaching.., March 8, 2000
Reviewer: CarlJohan Bostorp (see more about me) fromLinkцping, Sweden
I seriously like this book. It's explaining is close to crystal clear to me when I read it, and the algorithms listed (in pseudocode) take it to a practical level.
One of the best books of its type, February 1, 2000
Reviewer: Professor Dana S. Nau fromCollege Park, Maryland
One of the best ways to discover the strengths and weaknesses of a textbook is to teach a course using it. A few years ago I taught a seniorlevel course on Data Structures using this book. The book was a joy to teach from, and I would happily use it again  I thought it was one of the nicest textbooks I've ever used.(In case you haven't figured it out from the above paragraph, I believe that Paul Schreiber's review of this book is far too negative.)
*** Introduction to Algorithms (MIT Electrical Engineering and Computer Science Series) Thomas H. Cormen, et al / Hardcover / Published 1990
Inadequate Computer Science, October 18, 1997
Reviewer: paulschreiber (see more about me) fromWaterloo, Canada
In this book, Lewis and Denenberg attempt to explain data structures and associated algorithms. They rely too heavily on obscure proofs, have few, if any workedout examples and many ambiguously worded questions. Their assertion that a "high school" math background is needed is clearly false. The book also suffers from poor typesetting.
Amazon price: $65.00 Amazon rating: ****+ Boring. Be forewarned this is an intermediate MIT textbook that stress algorithm analysis. Sedgewick's book is more simple, TAOCP is more advanced. The analysis of the algorithms are bit too lengthy. As one Amazon reviewer put it:Captivating... Masterful... (unless you have a life)
Though quite thorough, this book is a "textbook example" of how boring the subject of computer science can be. Instead of touching on new technologies, such as AI, graphics, or anything else remotely relevant to today's demands on programmers and designers, this book, faithful to its MIT roots, gives a pompous, eggheaded distortion to the field of computers as a whole. Its focus is mainly on such trivialities as algorithm analysis, offering about 10 pages of proofs for each simple assertion. The points that the authors hope to make have no relevance whatsoever in a world in which processor power, not meticulous code optimization, reigns. This book is a waste of matter and not worth the paper it is printed on.
See also ../Lang/c.shtml
Informative, but terribly unclear, June 29, 2000
Reviewer: Jia Jiang (see more about me) fromProvo, UT USA
As a computer science major in Brigham Young University, this book is required for 2 of my Sophomore classes. I am impressed by how much information this book contains. However, it is by no means clearly written. The wording is poor, the examples are vague, and the exercises are especially unmeaningful. Obviously, the author of this book is a computer scientist, but this shouldn't be the excuse for writing such a terrible book. Two third of my class hate this book, and we are thinking about having a festival to burn them together after this semester is over. we are asking for a better book which will hopefully contain the same amount of information, but better wording and examples.
Gary J. Bronson
Paperback  780 pages 1 edition (February 15, 1996)
International Thomson Publishers; ISBN: 0314069879
Amazon.com Sales Rank: 490,656
Avg. Customer Review:
Number of Reviews: 3
Very well written Data Structures text! May 28, 1999
Reviewer: A reader from USA
This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier
Mark Allen Weiss / Hardcover / Published 1996.
Amazon rating: Actually the author use C++. Not recommended.by Michael Main, Walter Savitch
Amazon Price: $67.00
Paperback  783 pages, 2 edition (July 25, 2000)
AddisonWesley Pub Co; ISBN: 0201702975
Other Editions:
Paperback
Avg. Customer Rating:
Number of Reviews: 11
In a a rare book that can be used in both Windows/VC6 and Unix/gcc environments. The authors have a Web page AW MainSavitch Supplements Data Structures ... Using C++ . The book has a good WEB page with a lot of useful materials. I think it's the best WEB for the book site among books in this section.
These are the supplements for the second edition. The first edition supplements are still available at www.cs.colorado.edu/~main/dsoc1/dsoc.html, though instructors who are using the first edition should be able to shift to the new edition with little change. The primary additions to the second edition are features from the 1998 C++ Standard. Here are links to some summary material:
by Mark Allen Weiss
Hardcover  896 pages 2nd edition (November 5, 1999) AddisonWesley Pub
Co (Net); ISBN: 020161250X
The first four chapters is an intro to some C++ constructs. Chapter 5 is
design patterns. Chapter 6 is about algorithm analysis. At this point most
students hate the course, instructor, C++ and, especially, the book ;)
Those few who survived and were able to get to the Chapter 8 and beyond may get something useful from the course. Actually the rest of the book is not that bad. Chapter 15 Graphs and Path contains a decent discussion of the Dijkstra algorithm.
The book covers a lot of interesting things, like Minimum spanning tries (24.2.2)
by Adam Drozdek
Amazon Price: $69.95Must read book on Data Structures, June 14, 2000
Reviewer: appan (see more about me) fromU.S.
In a world of Data Structures books on C and Pascal, this is the best book on using C++. Particularly, I like Author's style of explaining the concepts by pictures and examples instead of drolling over by numerous definitions.This book also concentrates on various advanced DS topics including Hash Tables, Advanced Search techniques and Memory Management. Case Studies and Exercises are one of the best I have seen in this field  in fact, better than Savitch! I wouldn't miss this book. The price is worth the contents. This text refers to the Paperback edition.
by William Ford
Amazon Price: $73.00Publisher page Data Structures with C++
Excellent book with lots of handson examples. Recommended., May
24, 1999
Reviewer: A reader from Washington State
Ford and Topp have done an excellent job of creating a text with plenty
of handson examples. Almost all of the examples compiled
correctly with Microsoft Visual C++ with very few changes. A few examples
did have minor errors that were easily fixed. If you want a "handson" guide
to data structures, this book worked for me.
Besides all of the actual C++ examples, the authors include good illustrations and answers to selected exercises. I used this textbook for my Data Structures class and several of the students commented on how they planned to keep the book for future reference.
While C++ has always been sold as the "objectoriented" language, it can be used for a whole range of general computing tasks, like algorithms. This book provides a number of algorithms that are readytorun. This will open the door for C++ programmers to linked lists, stacks and queues, trees, arithmetic algorithms, and graph algorithms.
Some Aspects of Programming in C++. Arithmetic. Sorting Arrays and Files. Stacks, Queues and Lists. Searching and String Processing. Binary Trees. Btrees. Tries, Priority Queues and File Compression. Graphs. Some Combinatorial Algorithms. Fundamentals of Interpreters and Compilers. Appendix. Bibliography. Index.
Difficult reading, but Excellent Code, August 2, 1999I'd recommend this book for the advanced programmer or the programmer that has a great deal of drive and assistance. All in all, definitely worth taking a close look at.
The book covers a good amount of material and as the preface of the book states it is meant for a 2 semester course in data structures. The book covers stacks, recursion, queues, list, binary trees, sorting, searching, hashing, graphs, etc... All that is essential to becoming a well founded programmer. There are exercises at the end of each chapter to reinforce the material. The material presented is theoretical in nature not much C/C++ code but that's fine.
My opinion of this book has changed over the last year. I had to purchase the book for my first data structures class in college. After reading just the first chapter I was bewildered and confused! Most of the students agreed with me that it was a confusing book and without the benefit of an excellent instructor we'd surely would've been lost. I cannot stress this enough, unless you are very smart student this book should be a supplement to lecture material. I personally didn't read the chapters until after lecture and it usual for me read material before class.
But now a year after I first opened the book I find it a truly great reference. Certainly the book has grown on me and maybe later I'd probably give it a five. For example, recently I had to write a threaded example for my Windows programming class and I wanted to something time consuming yet simple that actually did something, so I just referred to the book on the fibonacci sequence using recursion and used that.
My final thoughts about this book are a bit strange. First off, this
is the only data structures book I have read (so far) therefore my opinion
lacks some perspective. At first I didn't like it but as time has passed
I find that I really like the book. If you are a student going into a data
structures class, most likely you'll be required to get a book on data structures
and it's possible that you won't get assigned this book. But I would recommend
it after you take the class. If you do get it for your class, don't sell
it back to the school! You may just find it useful in the future.
Certainly deserves more than 2 or 3 stars, August
11, 2000
Reviewer:
swarnangsu (see more about me) from india
Admitted it is not for a beginner, especially if
one doe s not have a proper grasp over C. But did the authors claim
that it was for beginners? I found their treatment of data structure to
be pretty interesting. The authors mostly give psuedo codes which can be
easily converted to an executable program. The numerous challenging
problems are a great asset of the book. I haven't given 5 stars
to the book primarily due to 2 reasons 1. some codes are unnecessarily
complicated (BST deletion, AVl tree deletion etc.) 2. though the authors
promise data structure in C++, they barely use any object oriented concepts.
Why beginner want to read this book?, April 13, 2000
Reviewer: Peter Liu from Purdue University
I am from Purdue University, this course is a core requirement for Electrical
Computer Engineering. I don't understand why are you beginners want to read
this book? You have to finished Advanced C Programming before even try to
read this book. It is not meant for rookie! This book is Data Structure
which teach you algorithms for sorting and search data using binary tree,
recursions, linklist and lots other algorithms. There are not much of C
code in the book, because once you understand the algorithms, you can implement
in any kinds of code you want.
I heard this same advice before buying this book and ignored it, I really wish I had listened back then.
While MAP has some nice pictures which broadly describe the essential concepts, it will give you no idea as to how to actually implement those ideas. Further, all the code is available in CPAN ( If you don't know CPAN, check it out before going any further  at the very least install a module ) and much ( at least what I attempted to use ) appeared to be broken.
Authors of computer books are usually good about answering email but these authors did not deign to respond to mine.
If you are out there, struggling to learn algorithms, I would suggest taking a good computer course on the subject. I'm 99% certain the course will be taught in C/C++ or similar language these languages have tremendous advantages over Perl when it comes to data structures and, believe me, even as a novice I've come to appreciate them...
If you really know algorithms and wish to write a few in Perl, you can do without this book. Pick up Deitel & Deitel's 'Perl: How to Program' instead or O'Reilly's basic book ( which is good, but I prefer Deitel and Deitel ) ....besides D&D answer their email.
This textbook thoroughly outlines combinatorial algorithms for generation, enumeration, and search. Topics include backtracking and heuristics search methods, applying to various combinatorial structures, such as:
* Combinations
* Permutations
* Graphs
* Designs
Many classical areas are covered as well as new research topics not included in most existing texts, such as:
* Group algorithms
* Graph isomorphism
* Hillclimbing
* Heuristics search algorithms
Kreher and Stinson have written a modern text that addresses the subject systematically, and from a variety of viewpoints. Their text is engaging and accessible to a senior undergraduate student. Nevertheless, a researcher will also find the text informative and useful. It provides an excellent balance of mathematical background, algorithm development, and algorithm implementation. The book has been designed to support an undergraduate course, and provides further material to support a more intensive graduate level course. The text has well designed chapter notes and exercises; the presentation of the methods through description, pseudocode, and examples is particularly clear. However, it is the selection of topics that makes this text especially good.
Numerous strong texts on graph algorithms are concerned with the analysis of properties of graphs rather than the generation and search for combinatorial objects. Highly structured combinatorial objects, such as errorcorrecting codes or interconnection networks, are notoriously difficult to find via computational methods. The authors develop a powerful toolkit of algorithms for addressing generation and search problems. They start with simple tools and then use these along with some basic combinatorial mathematics to build quite sophisticated tools. The text provides enough information to develop and understand each of the algorithms presented, and enough pointers for the interested reader to find more.
This is an excellent book. I enjoyed reading it. More importantly, there is no doubt that an interesting course can be taught from this book at either the undergraduate or graduate level. There is enough flexibility in the choice of material and emphasis to support a course on mathematical aspects, algorithmic techniques, or applications.
Combinatorics Topics, Techniques, Algorithms by Peter J. Cameron
What it says, it says best., August 17, 2003
No, there isn't any real source code here. That should not be a problem  this book aims above the cut&paste programmer. The book in meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways. String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other nondeterministic optimizations, and probabilitybased techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability. By the way, don't let the biological orientation put you off.
DNA analysis is just one place where stringmatching problems occur.
The author motivates algorithms with problems in biology, but the
techniques are applicable by anyone that analyzes strings. 
May 22, 2000 

Reviewer: Srinivas Aluru from Iowa State University, USA  
This is a great book for anyone who wants to understand string algorithms, pattern matching or get a rigorous algorithmic introduction to computational biology. Comprehensive textbook covering many useful algorithms. Very well written.  
May 15, 2000 

Reviewer: devolver@iastate.edu (see more about me) from Iowa  
A wonderful book that covers many of the basic algorithms (Z, BoyerMoore, KnuthMorrisPratt) and then moves on to a wonderful discussion of suffix trees and inexact matching. This is an essential book on the topic, but definitely targeting programmers; if you're not a programmer, this book could be a challenge. Of course, if you're not a programmer, this book may hold little interest to you.  
June 15, 1998 

Reviewer: Peter A. Friend (see more about me) from Los Angeles, California  
When you try to teach yourself a subject, you end up buying large numbers of books so that all of the little gaps are filled. Unfortunately, I didn't find this book until AFTER I spent a fortune on others. Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math. By far, the best book on the subject I have found, especially if you are "into" genetics 
Contents:
Foundations; Disjoint Sets; Heaps; Search Trees; Linking and Cutting Trees; Minimum Spanning Trees; Shortest Paths; Network Flows; Matchings.
Deservedly a classic, March 23, 2000
Reviewer: Tom Morrisette fromNew York City, USA
This is a superb book. I taught a graduate level course based on it at Lehigh University in 1984 or 1985. It was awarded the prestigious annual Lanchester prize for book of the year Operations Research Society of America about that time. Robert Tarjan was awarded the ACM's Turing award, computer sciences closest equivalent to the Nobel Prize for his contibutions to the theory of algorithms. This book is an excellent introduction to his work. The algorithms in this book were state of the art when it was published, but I don't know how close they are to today's best.Most of the optimal algorithms in the book grew out of Tarjan's pioneering work on algorithms that minimizes total complexity by allowing individual chunks of work to consume large amounts of computing resources if they build up "credits" that make subsequent steps more efficient. Until Tarjan used this approach to develop superior algorithms for a number of classical problems, the state of the art had been to limit the resources consumed by each step and bound total complexity by multipying the number of steps by the worst case resource consumption per step.
Tarjan's exposition illustrates the power of abstraction. He uses abstract data types throughout, carefully defining them in terms of their fundamental operations. This approach will be very natural for anyone familiar with object oriented programming.
There is a huge amount of information in very few pages, but it is organized very well. Often Tarjan's carefully chosen words say a lot more than is apparent to casual reader's. I spent one 75 minute period explaining his 12 line proof of one of his algorithms. Then the class demanded that I illustrate how the algorithm actually worked on a real problem, so we spent another 1.5 classes applying the algorithm to a small problem I contrived to exercise all of its boundary conditions.
Other faculty advised me that this book was much too hard for course intended for advanced undergraduate and beginning graduate students, but the students disagreed. More than one commented that the material was hard after first reading, but that after hearing my lectures and rereading their assignments, they realized that it was really pretty easy and that the book presented it well. Most would have appreciated worked out examples to observe the dynamic behavior of the algorithms. One student animated some of the algorithms and went on to write his masters thesis on algorithm animation.
**** Introductory Graph Theory [ABRIDGED] Gary Chartrand Amazon price: $9.85Very clearly written, July 14, 1999
Reviewer: A reader fromSan Jose, California, USA
A network here mean a graph with with weighted, undirected edges. This short (113 page) book is written in a clear style, and could be used as a textbook, athough it does not include exercises. Emphasis is placed on proving the efficiency of the algorithms presented. No knowlege of graph theory or algorithms is assumed, but knowlege of basic programming and collegeentry level math is required.The first half of the book covers the data structures used in solving the network problems that are presented in the second half. These data structures including disjoint sets, heaps, and search trees. Highlights of this half of the book are Tarjan's proof of the amoritized cost of union find, and explaination of selfadjusting binary trees.
The second half of the book covers four classical network problems: minimum spanning tree, shortest paths, network flows (e.g. mincut), and matchings.
I found the first half of the book more interesting, because more of it was new to me, and because it seemed more likely to be of practical value to me in my work. I have seen presentations of the network problems before, but not with the analysis of efficiency, and comparison of different approaches.
Robert Tarjan (the author) has written many papers on efficient graph algorithms, and appears to be a pioneer in applying proofs of efficiency to graph algorithm. He is often cited in reference to the efficient graph algorithms he has discovered.
This book was published in 1983, but does not seem to be dated.
Paperback  294 pages unabrid edition (April 1985)
Dover Pubns; ISBN: 0486247759 ; Dimensions (in inches): 0.65 x 8.54 x 5.43
Amazon.com Sales Rank: 98,028
Avg. Customer Review:
Number of Reviews: 3
One can use this book instead of Cbased book by the same author. Although the book remains pretty average, this is mostly the book about algorithms not about C++. The author pays some attention to OO, as fashion requires, and then completely forget about it for the rest of the book.Algorithms on Strings, Trees, and Sequences : Computer Science and Computational Biology ~ Usually ships in 24 hours Dan Gusfield / Hardcover / Published 1997
The Data Compression Book by Mark Nelson, JeanLoup Gailly** Useful, but filled with many, many errors. May 4, 2000
Reviewer: robert_b (see more about me) from Seattle Washington
Despite the title, "Compression Algorithms for Real Programmers," the true audience for this book is not only programmers, but anyone who would like a brief introduction to compression algorithms and the patent politics impacting their use. The book is rather lightweight on details of the algorithms; as such, it is a good overture for programmers, but a dangerous source from which to create software, as "real" programmers often do.
This book was an introduction to the field for me, and for that I found it valuable. However, even though I am a compression neophyte, I found many errors in the examples and the explanations. What concerns me is that if compression novice, as I am, can find errors, how many more hidden errors are in there that I could not deduce? These mistakes often made it difficult to understand the algorithms the author is trying to explain. Not only must one try to comprehend the algorithms, one must first determine what the author actually meant to write. In addition, there are errors in grammar and typesetting that impact the smooth reading of the sometimes complex text.
The book would have benefited greatly from a careful reading by three editors: a technical reading by someone in the intended audience, a technical reading an expert in the field, and a literary reading to smooth out the writing, correct the grammar and point out the typesetting errors. Had the author and editors been more careful, I would have given the text four stars rather than the two.
Use it as a first book, an introduction, for ideas, and source for references. However, follow up on the references before proceeding to create even a line of code.
good conceptual book
April 26, 2000
Reviewer: Craig Schmidt (see more about me) from Boston, MA Most of the compression books I've seen have either been very mathematical using a theorem/proof presentation, or code cookbooks that don't explain the ideas very clearly. This book uses that all too rare "conceptual" presentation. It very clearly explains the main ideas in compression, with very few equations. The examples are nicely chosen. I would strongly recommend this as a first book on compression. However, it is also a very enjoyable read for people more familiar with the field. The chapter on patents is very interesting even for experts.
June 19, 2000 

Reviewer: Andrei A. Istratov (see more about me) from Berkeley, CA  
PROs: 1. It is one of very few books on data compression
available on the market. 2. Description of the IDEAS of compression
techniques is very well written. 3. The books comes with the C code
for most algorithms. 4. Fairly wide scope of data compression techniques
is presented.
CONs: 1. Possibly for copyright reasons, the formats of commonly used file formats are not disclosed; the enclosed propgrams are generic compression algorithms, which do not create (or open) actual .ZIP, .ARC, or .JPG files, which can be opened by commercial programs. Therefore, this book will not help you to open standard compressed files from your homemade programs. 2. There is a missing link between the well described ideas (general principles) of the compression techniques, and their actual algorithms presented as C programs  namely, the algorithms are not described verbally. You have to analyze typically 6pagelong programs to understand how the actual encoding is done. 3. Although there is a section on sound compression, the MP3 standard is not explained. The same applies to MPEG. SUMMARY: Good to get a general idea how the data compression is performed. Helpful if you want to develop your own compressed data format. Of very limited help if you want to work with standard compressed files in your own program. Requires knowledge of C and some time to study the enclosed code. 
June 15, 2000 

Reviewer: Gretta E. Bartels (see more about me) from Seattle, WA  
This book's target audience is the novice C programmer who needs to implement data compression of some kind. The authors go to great pains to explain exactly how the code works, but they don't do as good a job on the algorithms themselves. If you are a competent C programmer and/or have any formal training in algorithms, this is probably not the book for you, though it may be a good jumpingoff point if it's the only book you can get your hands on.  
September 1, 1999 

Reviewer: A reader from Florida, USA  
This book did a better job than any other of teaching me sliding window dictionary encoding and adaptive huffman encoding. It got right to the point in an easy to understand fashon. There was no thick cloud of theory masking the information I needed. Read this book before you read others on the subject of data compression.  
May 24, 1999 

Reviewer: A reader  
The data compression topics are covered in the most lighthanded way possible. The promos for the book advertise that the JPEG compression standard is "discussed", and that source code is provided ... but the source code provided is NOT a JPEG encoder/decoder, but rather an abstract Huffman Table/Quantization program that is ONE HUNDRED FRICKIN' PERCENT USELESS. 
May 2, 1999 

Reviewer: EECS PhD (eecs_phd@yahoo.com) from Hong Kong  
This book explains lots of algorithms, the author
tries to give you a brief overview on each of them.
However, if you're interested in the concrete ideas and proofs on how the algorithms help you to compress your data, with some mathematical works, the book isn't enough. You'll find it difficult if you want to implement the algorithms by merely reading the book. Some idea are not clearly explained too, say, the the information on Gzip is just a summary of the GNU documentation with no indepth discussion. Anyway, this book is a great one judging from the (sad) fact that there are not many references on the subject. 
September 27, 1999 

Reviewer: A reader from Sunnyvale, CA  
I had the opportunity to examine this book both in manuscript and published form, and I must say that I am quite impressed. It provides good overview and detailed implementation notes with source code examples for a variety of image formats. The chapters dedicated to JPEG explore many aspects of the standard and offer suggested implementation notes for both compression and decompression, and the book would be valuable based on this information alone. The remaining chapters discuss the common GIF format and its patentfree successor (PNG) as well as other compressed image formats in regular use. Source code examples in C++ are included in the enclosed CDROM along with sample images. In summary, Miano's book provides a sturdy reference for graphics programmers or anyone interested in the details of today's most popular image formats. 
Brilliant! September 2, 1999
Reviewer: A customer from Australia
It's a perfect blend of algorithms and mathematics, some of which take a little while to comprehend (if like me, you're not a mathematics graduate), but it's more than worth the effort.
Of all the books in my bookshelves, this would be the one I'd save in a fire. Sorry Knuth. :)
Extraordinary Book on Cryptography September 24, 1998
Reviewer: Paul M. Kwasny (paul@ata.com.pl) from Cieszyn, Poland
Very good book if you are interested in cryptography and secret maths. Not many publication on this topic are written as clear as this. Other like Neal Koblitz's Book on cryptography is a lot harder for people on lower level of maths knowledge. I recommend it to those who want to learn something or for those who want to refresh their memory .
The Advent of the Algorithm The Idea that Rules the World by David BerlinskiAmazon price: $19.60
Hardcover  368 pages 1st edition (March 6, 2000)
Harcourt Brace; ISBN: 0151003386 ; Dimensions (in inches): 1.18 x 9.30 x
6.25
Amazon.com Sales Rank: 990
Avg. Customer Review:
Number of Reviews: 3
September 3, 1999 

Reviewer: ahmaden@starnet.com.eg from Cairo, Egypt  
This is a truly magnificent book. It comprehensively covers most of the topics in the analysis and design of alogorithms with no mathematical burden to hamper you from getting through this subjet. Later on, you will most probably need a more intensive and mathmeticalanalysis oriented book but be sure this second book will be far more easy to go through after you have have finished the "Algorithmics" book. Enjoy it.  
3 of 3 people found the following review helpful:  
April 13, 1999 

Reviewer: A reader from Finland  
This book is just fantastic. It gives a perfect introduction to the most important aspects of algorithm design, correctness, complexity, P vs NP, etc. It has solid foundations in the theory, and brings these difficult concepts within reach of the average programmer, in an easily readable style. Kudos to the author.  
December 12, 1998 

Reviewer: Mohamed Samy ( samig@gega.net ) from Cairo,Egypt  
The book is an introduction to every aspect of algorithm analysis and design ,with chapter on parallel algorithms, algorithm analysis, algorithm design, Turing machines, algorithm correctness and so on. I recommend the book as an introduction since each subject it covers needs a book of it's own so it can't possibly cover every aspect of these topics 
Society
Groupthink : Understanding Micromanagers and Control Freaks : Toxic Managers : Bureaucracies : Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Two Party System as Polyarchy : Neoliberalism : The Iron Law of Oligarchy : Libertarian Philosophy
Quotes
Skeptical Finance : John Kenneth Galbraith : Keynes : George Carlin : Skeptics : Propaganda : SE quotes : Language Design and Programming Quotes : Random ITrelated quotes : Oscar Wilde : Talleyrand : Somerset Maugham : War and Peace : Marcus Aurelius : Eric Hoffer : Kurt Vonnegut : Otto Von Bismarck : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce : Oscar Wilde : Bernard Shaw : Mark Twain Quotes
Bulletin:
Vol 26, No.1 (January, 2013) ObjectOriented Cult : Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks: The efficient markets hypothesis : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Vol 23, No.10 (October, 2011) An observation about corporate security departments : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law
History:
Fifty glorious years (19502000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds : Larry Wall : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS : Programming Languages History : PL/1 : Simula 67 : C : History of GCC development : Scripting Languages : Perl history : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 19872006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history
Classic books:
The Peter Principle : Parkinson Law : 1984 : The Mythical ManMonth : How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite
Most popular humor pages:
Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editorrelated Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPLrelated Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perlrelated Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assemblerrelated Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor
Copyright © 19962014 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine. This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...
You can use PayPal to make a contribution, supporting hosting of this site with different providers to distribute and speed up access. Currently there are two functional mirrors: softpanorama.info (the fastest) and softpanorama.net. 
Disclaimer:
The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.
Last modified: January 12, 2014