Customer Reviews

Ready-to-Run Delphi(r) 3.0 Algorithms

5 star:		(1)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(1)

 

 

I really wanted to like this book mainly because there has been nothing like it for Delphi. The algorithms hare handled competently enough and the breadth is all one could ask for in an introductory book. The code however is pretty bad. It shows that Mr Stephens converted it from Visual Basic and that he doesn't have enough Delphi knowledge (eg using / instead of div, integers are NOT 2 bytes). It isn't Ready-To-Run by any stretch of the imagination. There are some annoying lapses in the text as well (a nice chapter on hash tables but nothing about hash functions?). As far as I can tell no tech editing was done and it shows. Nice try.

Having read excellent John Wiley books in the past, I had great expectations from Ready-to-Run Delphi 3.0 Algorithms. Unfortunately, this book is far from being a good book. First of all, the author, Rod Stephens, is not a Delphi programmer. He merely ported, or more precisely attempted to port, one of his previous Visual Basic books to Delphi. Several Delphi code listings contain code that is... Visual Basic code!

Furthermore, the title is totally inappropriate: none of the supplied code is "ready-to-run." In part because it contains too many errors, but more importantly because the sample code is too academic to be really useful in a real life application.

Do not waste your money on this title.

This book has an excellent collection of classic and modern computer science algorithms. Unlike many other similar books, Rod Stephens (the author) goes deep into every topic. For example, under "searching" most books write about why do we need searching, describe exhaustive searching, and then finish with binary search, saying "look: we can search among 16 items with only 4 comparisons, - is that cool or what?!" On the other hand, here is what "Ready to Run Delphi 3.0 algorithms" has under "searching": exhaustive search, searching sorted lists, searching linked lists, binary search, interpolation search, string data, hunting and searching, binary hunt and search, interpolative hunt and search. The chapters are Fundamental Concepts, Lists, Stacks and Queues, Arrays, Recursion, Trees, Balanced Trees, Decision Trees, Sorting, Searching, Hashing, Network Algorithms, and OO Techniques. I gave 4 out of 5 rating because although there is a lot of stuff in there, some important algorithms are missing. Minimax discussion is not followed by alpha-beta pruning. Heuristics, probably the most interesting part of decision trees (at least to me) is barely touched and no sample code is given. To summarize, this book' material is what I went to university for.

I own 20 Delphi books (I am the author of one of them), and this book is one of the select few that I come back to time and again.

I was hoping someone would do a "concise", Object Pascal-specific version of "The Art of Computer Programming", and here it is.

The title is unfortunate, I think. It should be something like "The Art of Delphi Programming"; the material here is virtually timeless, not Delphi 3-specific.

While there are minor lapses here and there (for example, a data type of "string * 20", which won't compile in Delphi (it should be String[20])), that is a very minor problem.

If you are a Delphi developer and need to learn about lists, trees, sorting algorithms, etc., search no further: this is the book you need.

Clay Shannon

I found this book interesting, and at times a pretty hard slog, to read. It covers all the common programming problems such as searching, sorting, stacks, ques etc. Although the book says it is for Delphi 3, the code is generic and would work equally on later versions. I have yet to use some of the code in my own programs but I found some of his thoughts interesting, especially recursion eg. most books would use it for binary searches or factorials but as he states it would run much more efficiently by placing it in a simple loop!, a fact that most other discussions fail to recognise. He points out that while one approach may be suitable for some problems you should realise that sometimes what is a 'less efficient' approach may be better eg. don't use hashing or binary searches on short lists, exhaustive is better. It is a book that most programmers will be able to 'do without' but if you think you may need to do some of the things discussed in the book, it is probably worthwhile thinking of getting a copy.

You really find many things here: stacks, lists, trees etc... But the code is not very clear. And they use pointers a lot. Some simulations would be good too...