5 comments about Computer Algorithms C++: C++ and Pseudocode Versions.

1. This book is a textbook for a Computer Science course "Analysis of Algorithms" in Queens College, CUNY. The entire class suffers, because the book isn't readeable. The language isn't English!

   Authors strive to make even the simplest algorithms difficult to understand. The code examples have almost no comments and are typed in a messy disordered fashion. Mathematical analysis requires huge background in analytical mathematics and prior knowledge of everything it talks about. Proofs of theorems are not clear. Where the authors state something like "... clearly this is so-and-so... " the argument isn't even logical!

   Very often they don't even describe an algorithm - they just say "the algorithm is presented by the code on page ..." (this page is usually 10 pages away). The number of typographical mistakes is enormous. The examples are based on bizarre numbers and data structures.

   Don't ever ever ever consider buying this book! For college professors: please don't use this book as a textbook in your class unless you want to have a "D" average at the end of the semester.




2. I'm a student at department of Computer Science and Information Engineering, National Taiwan University.We took the course "Algorithms",and used this book as a text book.After a semister learning, i never heard any good comments for this book.The most word given to this book is"This book can make easy to hard!"We'll never choose this book as a text book again.



3. This book discusses algorithms in computer science but does integrate enough C++ code into the text, in spite of its title. Also, a lot of the code still has remnants of C philosophy, such as #define statements, in spite of the authors frequent use of "class" in their code. Buy this book with caution, as it is very expensive.



4. Don't waste your money on this text, it is rotten. I had it for a class and found this book to do very little in aiding the learning process due to its lack of any sort of coherent explaination. I ended up purchasing another text and used it from then and until now, after college.

   this is the only textbook i have ever sold back after the semester.




5. ... If the primary complaint against this text is that the authors have not provided enough C++ source code examples for the types of algorithms explained, take a look at the price tag. At a list price of [price], one can logically deduce that this text is for a university audience, emphasizing the theory behind the algorithms, as well as the synthesis it takes for you to generate modified versions from the templates presented. If you are looking for a more "how to"-oriented text (you know, the kind that "spoon feeds" you) with excessive source code examples, you definitely should look for another text. Nevertheless, I consider this book to be both highly appropriate and effective for its intended audience.

1 comments about Programs and Data Structures in C: Based on ANSI C and C++, 2nd Edition.

1. After purchasing 2 other books on data structures, both of which were good for the experienced programmer but unclear for a student like me struggling to get through my data structures class, I finally found one that is perfect for explaining advanced data structures. The author breaks down multiway trees, heaps, linked lists, etc., in understandable terms. The sample code is complete and variables are intuitively named. Don't waste you money on other data structures books, espcially Data Structures & Program Design in C by Kruse. This is the textbook for my class and is universally hated among nearly everyone who has to use it. Ammeraal does a great a job with this book and is a must for the beginning CS student.

5 comments about Data Structures, Algorithms, And Applications In C++.

1. This book was a huge waste of money for me. I found that everything in the course could be found on the internet just by typing in the topic. The explanations in the book are very poor and the code is abominable (Sahni has obviously NOT worked in industry for a LONG time). Buy the Korrano (or however you spell it) book if you can, maybe just look in your old "Learning C++" (etc.) textbook-it may have more Data Structures than you think.



2. I found this book useless. I never used it during my (second quarter) data structures class (in which I received an A+). The first half of the book is decent as a reference but the chapters on greedy methods, divide and conquere, dynamic programming, and backtracking/branch and bound do not supply the user with proper examples to follow what the author is talking about. It is often hard to tell to which example he is refering and he tends to only give final results to a problem rather than step-by-step solutions. Often the author's code is bad (full of memory leaks) and some of his methods to speed up the code are wrong. Many data structures professors at universities have great on-line notes, and I found these infinitely more useful.



3. I'm a CS student from India, and I'd like to warn you not to buy this book. This is a 'recommended' book in our syllabus, but till now I can't understand why. The programs do their best to confuse you, and still can't get the picture after hours of stepping through the code. I don't know how Mr.Sahni intended students to understand this utterly foxing book. Stay away from this.



4. The book Sahni wrote with Horowitz was, and remains, a classic for anyone who wants to grapple with DS. Even the original text was never intended for starters and this book more or less carries on the same tradition (although a little more verbosely).
   The beauty of the original Horowitz and Sahni text was not the (terse) text, but the amazing exercises. The new one by Sahni also has some very challenging exercises suitable for advanced undergraduates.
   Students NEW to the subject are better of with simpler texts(I read the one by Kruse in my day, but there are PLENTY of new ones around) but students with more than one year of programming experince will find this book more challenging and satisfying. As for graduate students - Knuth awaits you with open arms. :-)



5. I'm actually amazed by the absolute mediocrity of this book. After having read a few books on *good* style (try Stroustroup, Effective C++ by Meyers), the code in here is crap by comparison. In addition (at least in the 1998 edition), there are all sorts of programming blunders - case in point: on pg 140/program3.20 there is a function to search for data in a circular list which ends up putting the data in the head-node for the list and leaves it there. Thankfully this garbage piece of code won't compile due to typos! Did anyone bother proof-reading this book? How did the author get a PhD? Only buy this book if you already know C++ and want a good laugh.

3 comments about Understanding Directory Services (2nd Edition) (Kaleidoscope).

1. This book provides more than a theoretical overview. The authors dig deeper and explain design ideas to implementation issues. The book is written for technical professionals and not "managers". (no offense)



2. This book is for technical managers who are evaluating directory services, and enterprise architects who are designing the infrastructure component of an encompassing enterprise solution. Other audiences include: portal designers and developers who intend to employ directory-enabled identification and access, and IT security professionals who are designing enterprise-wide role-based access controls and application-independent security architectures.

   In a nutshell (with apologies to O'Reilly & Associates) this book gives a balanced view of the major directory services solutions on the market. It starts with a high-level overview of directory services, how they can fit into an enterprise architecture, and the mechanics of directory services in general.

   The first directory service discussed is the grandfather of them all: X.500. If you are evaluating directory services as an enterprise infrastructure component, carefully read this part because it will give a solid basis for understanding the strengths and weaknesses of each approach that follows. This section of the book is suitable for "technically-challenged" managers, as are the introductions to each of the directory services discussed in the book.

   X.500 is followed by a detailed description and technical discussion of each of the commercially available directory services. The descriptions and technical discussions follow a fixed format and structure, making comparison easy.

   The directory services that this book coversare: LDAP (lightweight directory access protocol), DNS (domain naming system), Novell's NDS and Microsoft's Active Directory. It is interesting to note the order in which directory services are discussed. The authors start the book with open standards-based services (X.500, LDAP and DNS), followed by NDS, which is proprietary, but conforms to LDAP version 3. They save Active Directory, which is completely proprietary, for last. Also note that this book is written by what looks like a husband/wife team, one of whom holds Microsoft certifications and the other with Novell certifications. Both demonstrate an in-depth knowledge of directory services discussed in this book, and they have managed to give a completely unbiased view of the advantages and disadvantages of each service discussed.

   The reason I gave it four stars is because it badly needs to be updated to reflect what is currently happening today. I took into account the fact that this book was published in December 1999. I also took into account the fairly long lead time between the time a book is written until it is published, and the fact that the information in this book probably reflects the market and state of technology as it was in early 1999. However, the publisher should realize that this book needs to go into a second edition if it is to remain authoritative and valuable.

   Here are some examples of gaps:

   (1) Novell's NDS now goes by the name "eDirectory" and has been strengthened by their DirXML product. eDirectory is LDAP version 3 compliant, and DirXML is also on its way to becoming an open standard via the DSML consortium (see below). DirXML integrates with eDirectory to monitor and report change events through an XML interface. This is an important management feature for enterprises.

   (2) Another gap is Microsoft is not standing still either and is giving some signs of embracing open standards. Their SOAP (Simple Object Access Protocol)approach might open Active Directory, making it a safe choice that might actually go across platforms. I am not saying that it will happen - just saying that it is possible.

   (3) Finally, I feel that this book should be updated to include DSML (Directory Services Extended Mark-up Language. This is an open, industry standard specification that is sponsored by some large players. DSML will provide a standard for querying the data in directories and allow cross-directory exchange of information about their data. The exchange mechanism in this standard is XML, making the extended directory services available to any Web application that supports the XML standard. This is obviously of interest to the target audience and needs to be addressed in a second edition.

   Despite the gaps I found this book to be a valuable resource, and the best book available for learning about directory services technology. I applaud the authors for their unbiased treatment of the subject and hope that they will update this book with a second edition.




3. This second edition represents a major overhaul of the first edition, and addresses each of the issues cited in the previous review. The authors have done a remarkable job in this edition by clearly explaining the fundamentals of directory services in general and going into the details of specific implementations that have either a large installed base, are used by large corporations or both.

   Highlights include complete and clear explanations of directory services at the conceptual level, how they fit into an enterprise-wide infrastructure, and how they have evolved as the foundation of identification and authentication, as well as a more pervasive security approach.

   The early models, DNS and X.500, are given detailed treatment. Although DNS is not a feature rich directory service, it does qualify as a legitimate one and its inclusion is a nice touch. I liked the clear explanation of LDAP, which either is implemented in many organizations or is the basis for commercial products such as Novell's eDirectory.

   Two commercial products that are covered in great detail are eDirectory and Microsoft's Active Directory. Since each author has extensive experience with, and certifications in, these products the material is credible and sets the book apart by giving a balanced view of two competing products without bias towards either.

   Three other parts of this book are valuable:

   (1) Discussion of metadirectory services - this section covers the basics and contains good (but brief) material about Siemen's DirXMetahub, Sun/Netscape's iPlanet metadirectory and Microsoft's metadirectory services, Novell's DirXML and Radiant Logic's RadiantOne VDS. While these products are in many ways niche players (except for the Microsoft and Novell offerings), the description of them indicates where metadirectory services are evolving.

   (2) Directory mark-up languages - this section covers XML and offshoots that are specific to directory services, such as DMSL and Novell's DirXML. Given the fact that XML is a web services building block this section of the book is particularly valuable.

   (3) Evaluating directory services - the complete, unbiased method for evaluating directory services that the authors provide reflect their objectivity as well as a sensible approach to ensure that both business and technical factors are taken into account.

   If you are exploring directory services as an infrastructure component or need to understand them, this book provides the most objective and complete explanation of the fundamentals and key issues, as well as a survey of standards and products. It's up to date and easy to read.

2 comments about Advanced C/Book and Disk.

1. This book is an easy to read, advanced C programming book. Unlike the hundreds of C texts out there, this one features advanced topics such as creating dbase compatible files, working with BTrees and advanced data structures, with plenty of example code. Granted, some of the information is now a little dated, but still, I have gone back to this book many times.



2. Please be aware, a disk from 1992 (the book's publication date) will probably not still work, even if it is the right format. Disks deteriorate.

5 comments about Professional Dcom Programming.

1. This book is very confusing. A lot of high level words without any clue as to what do they mean. COM features are explained extremely poor.



2. The book's title is totaly wrong, it should be like DCOM Programming in VC++ with ATL, because that's the only area it focus to, it's good on that though it lacks a lot for being professional, discusess very little DCOM itself.



3. This coming from an author of 2 books on the subject. It is a difficult read, but the content is by far the most accurate and complete.



4. It is a great book for average COM programmer who wants to fully understand details of security, marshalling and multithreading in distrubuted environment. The author concisely explains these complex topics in lucid manner. The combination of theory and code samples is optimal. The book may not be good for beginners(who don't understand COM) or very advanced COM/DCOM programmers, But it is just prfect for intermediate level COM/DCOM programmers.



5. Micro$oft is famous for its ability to push out new development technologies. The reason behind this planned obsolesence is obvious, every time they come out with something new people will have to open their wallets to "keep up."

   DCOM is just another disposable technology. As such, it was a complete failure; one that the marketing folks at M$ have tried to bury as quickly as possible under an avalanche of .NET hype.

   DCOM was hard to port because, like COM, it is based on a binary standard (i.e. a standard that changes when you leave x86 and go to 64-bit RISC). Not only that, but DCOM doesn't support distributed transactions. Worst of all, DCOM is a very, very complicated technology to use. Three strikes... YOU'RE OUT!

   The half-wit MBAs at Micro$oft realized their mistake and have abandoned DCOM, leaving it forever in the backwaters where the only record of its sorry existence are stupid books like this.

   I have no idea why someone would want to buy this book. Folks, this is a dead technology. It is no more. It is an ex-techology. If you buy this book, you are lying to yourself. This book will sit an gather dust, unless you can find more productive uses for it...like burning it to stay warm.

5 comments about Distributed Applications With Microsoft Visual C++ 6.0 McSd Training Kit: For Exam 70-015 (Dv-Mcsd Training Kit).

1. I only program 1 year. I read book and pass exam no problem I love it. I recommend for new programmer.



2. This has got to be the BIGGEST rip off of all time. It is quite an achievement to write a 750 page book that contains NO USEFUL INFORMATION whatsoever. A full useless pages here, a few pages copied from the MSDN guide there, and very quickly we have a book full of useless information. DO NOT BUY THIS BOOK! The explanations of COM, ATL etc. are so short that, unless you already understand them this book will not help you and if you do already understand them you don't need this book. In either case the book is worthless when it comes to these topics. The authors have clearly looked for every opportunity to increase the size of the book without considering the worthiness of the content. We have 4 pages of installation instructions for programs that do not come with the book anyway. Each of these programs (Windows NT) will come with their own set of instructions so these are a waste of space. The chapter (10-20 pages) on the Document/view architecture, printing etc in MFC is an EXACT copy of what comes with the MSDN CD's. If you don't have these CD's it is all available at Microsoft's website. The authors even go so far as to copy their own work on numerous occasions, e.g. the chapter summaries. These 1 page summaries usually consist of a word-for-word copy of what was written two pages ago. Again this is a geat way to make a thick (and expensive) book. Another example; Using Spy++. I am not a complete idiot and neither are the other people who read this book. Anybody who uses a computer can see what Spy++ offers simply by running the program. What we need are specific examples of when this utility is useful; maybe a test exercise for a program that is not working properly that we need to use Spy++ for in order to find the problem and fix. I have plenty of other examples of why this book is a BAD buy. If you want to pass the exam get a good book on MFC and another one on ATL, read the MSDN info. and read Inside OLE that comes with it. This way you will learn ATL, COM, MFC and learn how to write and distribute applications using Visual C++.



3. When I 1st started reading and studying this book, I thought it was great. Then I realized that I thought this only because it covered areas I was not familiar with. When I got to areas I WAS familiar with, I realized that the explanations were hard to follow and perfunctory compared to other books I had read on the same subjects. The EXAM CRAM series is much more readable and in-depth. The coverage of IUnknown, IDispatch, ATL and COM in general are hard to follow and too advanced for beginners. The accompanied CD is missing files required to compile and run the examples. All in all, it still won't hurt to have it as a reference once you do learn the basics elsewhere.



4. The book is extremely trivial and doesn't give you in-depth & thoroughly coverage of any of its topics. A lot of material is monotonous & repetitive and the author doesn't provide comprehensive clarification of some distinctive and important terms...In general, this book is completely waste of time and money...



5. A brilliant book that every seasoned Windows C++ professional developer must read.

   Firstly, I must take the time to correct the first set of amateurs that wrote bad reviews about this book. THE BOOK IS TO BE USED BY PEOPLE WHO ALREADY WHO KNOW SOME VC++ and want to get prepare to pass the 70-015 exam. Microsoft Visual C++ is probably the worlds greatest development environment for RAD development for the Windows environment and only the true gurus of industry can prove that they have what it takes to tackle this exam. Anyone expecting to tackle the more advance elements of windows programming from a C++ perspective should definitely add this book to their reference collection.

   IF YOU DO NOT KNOW ANY VISUAL C++ DO NOT BUY THIS BOOK. There are several other books on the market that that will run you through the topics that will aid you to becoming a competent VC++ developer. As a starting point, I recommend "Visual C++ 6: The complete reference" , "C++: The complete reference" , and "programming applications for Windows" and that's just for starters.

   BUY THIS BOOK IF YOU KNOW SOME VISUAL C++ (v6) and want master more advance topics. So far I have read the chapters covering topics on COM, DCOM, Document View Architecture, MSMQ, ADO, Sockets, Data Access, and ActiveX and that is not half of the advance topics that are actually covered by this text and I believe that they have been covered brilliantly.

   ONLY OWN THIS BOOK IF YOU WANT TO INCREASE YOUR VISUAL C++ KNOWLEDGE.

2 comments about Numerical Recipes Example Book (C++).

1. The C++ source code given here can be useful if you are in a hurry to implement an algorithm given in the main Numerical Recipes book. One might consider that a CD of the source code would be more useful. But the examples are short subroutines. Manually typing in the code from the book should not be a big deal for any of you.
   
   The example data sets used for inputs to some of the subroutines is also useful for unit testing.



2. Very good with Numerical Recipes. If you are experienced, it is good, if you are a fledgling, complement it with a beginers book. I recomend it.

4 comments about More C++ Gems (SIGS Reference Library).

1. If you are an experienced C++ programmer, its the book for you.



2. This book contains a number of very useful columns from the recently deceased C++ report. I found particularly useful the articles on implementation of assignment operators, exception safety, and the inner workings of the standard library containers (Gillan, Austern, Sutter). Actually, they are all really about exception safety - clues on how to write robust code that I needed to learn.

   The introduction to Lakos' Large Scale Programming tome was also a useful tipoff about physical architecture: I've been using Rational Rose for about 18 months, and now have a better overall picture about what the component diagrams are trying to do apart from represent the receptables my classes get put in.

   A rule one might apply is: if the cost of the book is less than your time spent to remove the errors you'd make if you didn't read it, then buy it. This one passes the test with ease.




3. You can read the State Pattern in the famous "Design Patterns" book, but the article in this book, "Finite State Machines: A Model of Behavior in C++" by Immo Huneke, explains why the State Pattern is the way it is. That explanation was missing from the "Patterns" book. Also, Robert Martin's intro to this article was helpful. Mr. Martin mentioned he has a freeware "State Machine Compiler". I downloaded it, and it works! Really cool. This one article alone was worth the price of the book.



4. This is a collection of articles from C++ Report. A big book at 500 pages, but well-read C++ users, even if they've never read The C++ Report, may have come across a lot of the material before.
   
   All of Herb Sutter's contributions (apart from a parody article about a 'BOOSE' language) have appeared in his Exceptional C++ trilogy, John Vlissides' article turns up in Pattern Hatching (itself a distillation of his columns in C++ Report), three articles by John Lakos are a distillation of his Large Scale C++ Software Design, and Robert C. Martin's discussion of The Open-Closed Principle is reminiscent (although by no means identical) to his coverage of it in his Agile Software Development book. That makes up about a third of the book.
   
   However, the rest of it was new to me. In addition to Herb Sutter's articles on exceptions, further treatment of exceptions is given in articles by Richard Gillam and Matt Austern. There's also coverage of the Monostate and External Polymorphism patterns, a couple of threading patterns by Douglas Schmidt and some architectural patterns: Taskmaster (for GUIs), and Alberto Antenangeli on object-relational mapping patterns.
   
   The quality of the articles is uniformly high, but of course the book does not feel particularly cohesive, given the large number of authors and topics covered. I would not say that, from the perspective of 2007, there's insights here that you absolutely cannot find elsewhere. And to some extent, if you're sufficiently into C++ that you would consider buying this, you've probably got a lot of the books I mentioned earlier.
   
   But taken on its own merits, there are lots of good articles covering lots of subject matter, including that oft-ignored topic in C++, threading. If you're a C++ junkie, and the compilation format of the book appeals to you, this is worth your time.

No comments about Introductory C with C++.