1 comments about Visual Object-Oriented Programming Using Delphi With CD-ROM.

1. I tried to buy this book a while ago. It went out of print or I couldn't get it. It has been a while since I've seen a Delphi Book by Mr. Weiner. I'm shocked that it's here. Mr. Weiner is a excellent writer of computer books. He always covers a computer language in great detail. I was impress with seeing his coverage of Delphi before the book went out of print. Then I bought his Eiffel Book and was blown away. So I know this book is going to leave a mark. Warning! This book may be a hazard to your social life. I want it!

5 comments about Tomes of Delphi WIN32 Database Developer's Guide.

1. I got this because it was listed as for Advanced programmers. But it does little more the walk through some very simple examples of the basic database issues of Delphi. If you are a beginner and need some hand holding to get you started on topics you already have a detailed explanation on. Then this book might help. But don't expect to learn much from it by itself. I would get a copy cheap from someone experienced that got suckered in to buying it.



2. Contrary to the opinions of most of the other people who have written reviews on this book, I thought it was great. I have been developing applications in C++Builder for about a year or so (and in Delphi for a few years before that), but never had to do anything too complicated with databases. I especially found Part II of the book extremely valueable and easy to understand.

   Even though this is a Delphi book it was invaluable to me in completing a C++Builder database application that I was required to write.

   In my opinion, if you aren't advanced enough to know how to do database programming in Delphi (or C++Builder), but would like to be, this book is for you. If you are already an accomplished database programmer, then you probably wouldn't look for a book like this in the first place.




3. This book is probably not for the advanced Delphi programmer as it states, but I found it useful.

   I come from an engineering background. Most of my prior programs are number crunching Fortran programs. I've switched to Delphi to do Windows programming. I had no database background.

   This book got me started with database theory, and database practice with Delphi. I must admit if I was a Delphi database expert and bought this book I would probably be dissapointed. But it fit my needs with good discussion and examples for my level of database experience.




4. If you do not know database, or you need a very slow introduction to both databases and how to use them in Delphi, this may be the book for you. The book touts itself as Advanced on its back cover level rating. I don't know what marketing manager came up with Advanced, but this book is not even Intermediate -- it is Introductory. Do you know relational databse design? Well, the table of contents divides this book into three parts, and Part One is relational database design. If you already know the basics, this is just a rehash of everything you already know. None of the examples in parts two and three could be called Advanced -- they are Introductory. This is a book for beginners. The only thing that might be a redeeming quality of this book is that the Appendix has an exhaustive list of BDE API calls, but if you don't need this text (sans examples, etc.), this book won't do you any good. I was very disappointed. CONCLUSION: LOOK ELSEWHERE.



5. I have spent a lot of time studying this book. The early chapters are the best. The book needs work. It has a lot of valuable information, especially for a programming student who does not have much database experience. Unfortunately, it has a few glaring errors and omissions. The book has graphics that are labeled wrong. It refers to files on the accompanying CD that do not exist. I couldn't find an errata page on the Internet for the book. If the book were taken through a very serious editing process and re-published as a second edition, I might buy the new version.
   However, the quality of the writing, the overall poor quality of the binding, and the annoyances of being mis-directed make this book a poor comparison to "Delphi 4 Unleashed" and the Tomes of Delphi "Algorithms and Data Structures." Buy this book, only if you gave up trying to read database chapters in the Delphi 4 Unleashed. Also, be prepared to make a few mental jumps when you try to follow the projects.

5 comments about Delphi Component Design.

1. This book is all about what goes behind the curtains. If are a crazy developer like me and interested in knowing how Delphi designers implemented different mechanisms such as WIndows messaging OLE COM this title is a must



2. The book is a breath of fresh air and covers a good basic foundation: attitudes of programmers, basic structures of OOP with objects:- various virtual methods, basic construction of building blocks, streams, other forms of communication and a few peculiar things to watch out on. I personally have no interest in databases were some may have. 32 bit is the way to go as I can now see access to the windows API with the assistance of the book and Delphi Pro.
   Danny points out its not necessary to understand every base object behind the object you are building off from.
   This is true if you wish to add a minor adjustment to a component. But this I believe this is a major miss conception if you are building a new and different component. And for this purpose the book dose not begin to address threading, what is happing in TObject, as TObject is not in Delphi Pro to view and is the fundamental object that every object is built from!!!!!!. This is no different than the Pascal 7 days when every one wanted to read the OOP code for them selves at an enormous cost for a copy.
   I'm not saying the book should cover the windows API as that's another subject on its own, but how a action is handled through the Objects, or how a windows event is managed though OOP:- draw, mouse button.....
   I need a book that should cover enough to be able to install an object into a base object like a speed button into an editor or a listbox connected to a speed button so something like TCombobox or TGraph is understood how each piece interacts and is constructed together as a unit. When the OOPer's get hold of this understanding the tools for Delphi could become available will become limitless to the users. VB definitely has this advantage over Delphi today because we do not understand enough to create something different or new. Give it another go Danny with an extra book, as it is easy to understand what you have written, be cursus to get such a difficult subject right. And you have made a breath of fresh air already into the subject that is very useful to those that have read your first book but some of us need to go further.



3. This guys are crooks. They advertise a book they DO NOT have, get your money and never reply to your e-mails.

   The book is supposed to be great, by the way.




4. This is purely a Delphi programmer's guide, but it unquestioningly well written, informative, and well-rounded: Anyone seeking to learn how Delphi's VCL component libraries work, how to development components of their own, or how to extend Delphi VCL components already available from Borland or third parties, should read this book. There is simply nothing else that comes close.
   
   Mr. Thorpe's writing style is clear, concise, and does a great job of exploring the topic at hand. Any competent Delphi programmer will be well capable of undertaking VCL development on their own if they have this book at their side. One point to note about this book is what used copies go-for on Amazon.com (and elswehere): I typically see prices of between $50 and $100, even though the book was first published about 10 years ago. How many other technology books, particularly for a specific software technology, remain in such high demand after such a long period of time?
   
   "Delphi Component Design" was written for the VCL [Borland's Acronym for "Visual Component Library"] as it was implemented in Delphi 3.0 - back in the mid to late 1990's: the implementation of VCL it describes is still the foundation underlying VCL as implemented in Delphi today, and is close enough to the modern implementation to still be a very useful text. However, since Delphi's product direction is to pursue .NET as opposed to enhancing the older VCL, the book's usefulness is limited to those who are seeking to maintain or enhance existing Delphi VCL-based applications. Even though I no longer work in Delphi, I still find myself called-upon often enough for Delphi support that I'm not going to give up my copy of "Delphi Component Design" quite yet - even despite the used copy prices I see!



5. Extending the hand dealt to you by the development package is where the quality programmers are separated from the mere developers; often the difference between an adequate product and a great one. If you are a developer using Delphi and want to advance to a higher level of production, this book contains the necessary boost. Anyone moving into Delphi component creation will find it essential. From properly choosing components from the Delphi Visual Component Library (VCL) to building your own components and interfacing with OLE and COM, most of the major topics are covered in detail, with sections of example code to really drive the message home.
   The book starts off with a brief explanation of the models used in Delphi, basic concepts of a component, and the analysis and design of new components. This is followed up by an examination of Implementation Details, the fundamentals of polymorphism, virtual methods, exceptions, RunTime Type Information (RTTI), streaming, messaging, OLE and COM interfaces, and optimization techniques. "Design Time Support Tools," opens with an overview of the Integrated Development Environment (IDE) and emphasizes the interface issues. Danny Thorpe wraps it all up with chapters on property and component editors, and experts and add-in tools.
   This book contains many insightful points. The chapter on virtual methods and polymorphism contains the best explanation of the implementation details of virtual methods that I have ever seen. This chapter could serve as a reference in any study of object-oriented programming. I've incorporated many of these points into my own training course. As one whose main approach to OOP has been via C++, I found this material invaluable when teaching a course in advanced Delphi recently. The clear descriptions of the underlying implementation distinctions between virtual and dynamic methods may save you in the area of performance. Knowing and understanding why virtual methods will defeat the smart linking of the Delphi compiler/linker can reduce the size of your EXE.
   When I am presenting exceptions and exception handling to experienced programmers, they always ask the following question: "What is the real difference between this and how we have traditionally handled errors?" In only a few pages, the author answers this question and puts forward two lists, "Rules of Thumb for Implementing Exception Handlers" and "Rules of Thumb for Raising Exceptions"; solid advice for both developers and educators who develop developers.
   Optimizing code when there is "abundant" stack space (surely a hint of heaven!), multiple threads and different system-defined string types differ from traditional tricks. These topics are all covered in the chapter on optimization. Just because this space is available is no reason to misuse it. Knowing that the stack will never shrink over the lifetime of the thread should force you to rethink overuse. Understanding that long strings are allocated on the heap rather than the stack should cause an occasional re-examination of approach. It is also gratifying to see that there is also a short section on sledgehammer techniques, or put another way, "genuinely useful hacks."
   There is also an occasional sweet sprinkle of humor. From polymetamorphicdata (care to guess what that is?) to TypInfo ("tip info") and GUID ("gwid") the jokes are appropriate and blend well into the message. However, they are grains of seasoning rather than the bulk of the flavor.
   Delphi is a development environment that provides the opportunity to do many things quickly and efficiently. Add in a copy of this book and you are ready to harness the true power of Delphi by creating your own components and pushing things to the leading edge of software creation. Some sections can be read and appreciated just for their insights into object-oriented programming and design.
   
   Published in Journal of Object-Oriented Programming, reprinted with permission.

5 comments about Tomes of Delphi: WIn32 Shell API Windows 2000 Edition.

1. you just cant afford not to get it, with the declining availability of good delphi source out there... its indespensible



2. Have only been been using Delphi for 4 months now. This book and the Core API are very good. I found them very easy to understand.



3. Imposing as the material in this book might otherwise be, I am most impressed with the clean authorship of the material. This book is more than a developer can reasonably hope for in a source reference. I expected to have to give maybe 10 days' time to absorbing it cover to cover, but it is written so well that most chapters require reading less than a page describing the chapter; and the rest of the material can simply be used. So full of treasure is this book that I spent hours the first evening just typing code into projects. All of it ran right the first time. I doubt a better book can be written on this subject, and will from here on consider any book with John Ayres' name on it the one to look at first on whatever the topic. A huge thanks to you John for doing your work so well. You made ours' far easier than we imagined.



4. I suppose it was just bad luck that the first API (ReadDirectoryChanges) I needed help with wasn't in this book. I ended up spending some time searching the news groups to get more information. Seems like ReadDirectoryChanges should have been included in a book that has been described as the "definitive reference for the Win32 API"... A bit disappointing.



5. I could say 5 Stars and it would be all what to say - but if you are not shure, what a type of book to choose that would be to few. Well I have this book for a long time and it is my bible. It is very practice indeed and close to the problems. My own projects have gone much more easier to solve. My own focus is on automation sectors and so I did some work for automating rs232 driven radio controls for hobbie and HAM- interested people. If you are interested in it so you can look at my website http://www.peter-geisler.de - looking to results from which I can say are a lot of ideas from John Ayres Tomes of Delphi - I rating it 5 Stars.

5 comments about Ready-to-Run Delphi(r) 3.0 Algorithms.

1. 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.



2. 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




3. 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.



4. 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...



5. 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.

No comments about Delphi in Easy Steps (In Easy Steps).

5 comments about Charlie Calvert's Delphi 4 Unleashed.

1. This book gives me a big dilemma! Firstly, I have to say that some parts of the book have got me out of lots of trouble by helping me to understand some difficult concepts that the (so called) delphi help writers hadn't a hope in hell of explaining properly.

   On the other hand Charlie does go on a bit. I don't think that at its root Polymorphism is a particularly difficult concept but he leaves you thinking that it must be, because he goes on-and-on about it. The other problem is that he assumes a lot of knowledge. For example there is a buckets of information about COM, ActiveX,OLE and the like, but nowhere does he tell you the relationship between all these things and when/why you would want to use them. This may not be a problem for some readers, but I haven't really managed to get much out of the later chapters as I don't have - and the book doesn't give me - a basic understanding of these Microsoft technologies. Yet Charlie goes on for page after page about the details of how Delphi implements COM, which just got me bogged down and very confused.

   Don't think I am being down on this book, I'm not! Just be carefull to make sure it is the book for you. I am quite an experienced programmer, but I have little or no knowledge of Microsoft technologies and as a result found their treatment in this book very heavy going and often next to useless.

   IMHO the text could have been a little more terse and they might have got in the chapters that are on CDROM. This practice is simply not acceptable.




2. Could you tell me when you will publish the new version of this book: "Delphi5 Unleashed" ?



3. If you have completed using the excellent book Delphi Bible by Tom Swan, than this title should definitively be your next book that you will need to work with.

   Charlie's style of writing is nothing short of brilliant. The writing style is very lucid and the complete book is highly structured and flows very smoothly. Having said that, you do not necessarily have to follow the book religiously from one chapter to another. Unlike tutorial books, where the current chapter builds upon the previous chapter, Charlie's book takes a diametrically opposite way of teaching you Delphi. A complete subject is treated in every chapter, which makes it considerably more useful for an intermediate to advanced developer.

   Some very important chapters are provided on the CD which does require you to take the time to print them.

   In summary - take my words, get the book, work with it and I can assure you that you will end up being if not an excellent Delphi programmer at least a well informed developer of Delphi's Advanced features.




4. Having read several good (and some not so good) books on Delphi, I would have to say that this book has some of the best content that I have seen. It is not for the Delphi developer just starting out. It does provide good insight into several of the more difficult aspects of Delphi and Windows programming. Several of the sections (including Calvert's discussion of COM) proved to be very valuable. His writing style is very straight-forward and he gives many examples in the book to help reinforce the topics discussed.



5. Having read several good (and some not so good) books on Delphi, I would have to say that this book has some of the best content that I have seen. It is not for the Delphi developer just starting out. It does provide good insight into several of the more difficult aspects of Delphi and Windows programming. Several of the sections (including Calvert's discussion of COM) proved to be very valuable. His writing style is very straight-forward and he gives many examples in the book to help reinforce the topics discussed.

5 comments about Delphi 5 Developer's Guide (Developer's Guide).

1. I just got a new programming job based in a Delphi environment. I was trained to work in Java and VB; fortunately the syntax was not too different so I picked up this reference book. I was pleasantly surprised to find that a single reference book made the transition go that smoothly.



2. I found this to be a fairly useful book. I usually refer to it AFTER I have looked at Mastering Delphi 5 by Marco Cantu. Probably the most useful thing that I found was not in the book at all. It was on the included CD...Chapter 8 of the PDF document has a section on Raster/Vector fonts that I found VERY useful.



3. Great book for intermediate programmers. Plenty of source code but it's chopped up and difficult to follow. The section on Creating Components was very useful to me. The CD is great, has many undocumented toys on it.



4. This book had a lot of useful information, but the formatting and the usage of the companion CD drove me crazy. Here is and example: I'm reading along and I finish chapter 5 only to find chapter 6, 7, and 8 are on the companion CD. For now I skip them, and go on to chapter 9. When I'm finished with that I find that chapter 10 is on the companion CD and it has all of the coverage on printing (one of the subjects I need), so I open the CD and start reading chapter 10. This is something like 54 pages, and it has some good subject matter. I decide to print a couple of the pages only to find that they have their security setting set so you can't print ANY of the book chapters (or highlight, so you can't copy and paste items). In all, the companion CD contains 447 pages of non-printable text from random parts of the book. If any subject interests you all you can do is write a note as to the page number and location on the CD, nothing else is allowed. I found it very hard to read an electronic page or two and then try an example and keep on flipping back and forth electronically. If this doesn't bother you then this may just be the book for you. I felt the information was good, but a book that can't be put on paper isn't for me.



5. The book is well written, however some chapters are avaliable on CD only with no print permission. I do not like reading books on my computer screen. If you don't like ebooks like me find another book

2 comments about Delphi/Kylix Database Development.

1. What I don't like:

   There is no errata for this book, so when example it does not work - you will loose time until you find out what is wrong, your code or if there is a typo in the book.

   Very short explanations for the examples. The Author should make a bigger effort to explain what he is doing.

   He uses some techniques in examples - but he does not elaborate them. Example: He uses in one example (page 109) "GetTickCount" but there is no explanations for what GetTickCount does. There are many situations like this in the book where the Author does something (uses some methods or properties) - with no explanations.

   What I like:

   Subject! This is the only book that I found on this subject.




2. This book is an essential addition to every beginning and/or intermediate Delphi programmer's arsenal.

   After a long struggle to fully understand the power of the TClientDataSet, this reader experienced what could loosely be referred to as a religious experience after reading chapters 3, 4 and 7. These chapters alone make the book worth many multiples of its price.

3 comments about Delphi Developer's Guide to XML (Wordware Delphi Developer's Library).

1. This book is not a beginner's guide. You will feel helpful if you need some guides in XML programming with Delphi.



2. This book is okay if you like the procedural way to get an overview of the major vendors for XML components. It assumes you know something already about websites and gives a good but (for beginners and intermediate readers) tough layed out protocol and implementation view.

   My advice: pick an XML implementation that fits your environment, read the first chapters on the RFC stuff (how it should look) and pass right on to the chapter for your implementation. Reading all the chapters can be quite confusing.

   I look at this book as a complete developer's review and it does help me understand how to program XML quite well, but more real-world examples would be welcome (there is one example in it, but in my opinion it does not cover extensive use of XML in larger environments).




3. To start with the disturbing fact: This book is about XML, but not about XML as supported by Delphi 6. Or more specifically, it is about XML, but doesn't cover any of the new Delphi 6 BizSnap XML features (XML Programming, Data Binding Wizard or XML Mapper).

   The book starts with a first part to introduce XML. In seven chapters, we learn about the history of XML (and XML vs. HTML), the XML syntax, the old DTD, XSLT, XLink, XPath and XPointer, and finally XML Schemas.

   The second part of the book covers the Document Object Model - all about parsing an XML document. DOM is one of the two main approaches you can take when parsing XML. The other is SAX (Simple API for XML), which is covered in part three.

   Part four is about Serving XML. This is mainly about viewing XML as data and not as documents. It describes a number of ways in which XML can be generated automatically, for example as text, from a database, using web modules (or InternetExpress), using DOM or SAX, and finally as MIDAS data packet.

   The last part of the book covers a number of applications that make use of XML, like an electronic e-mail sender, a customised client and XML examination application (both a Windows client and a Web client). The final chapter of the book even covers SOAP, but not the way Delphi 6 supports SOAP. In fact, I would not use the techniques in this chapter as they are far more complex than the Delphi 6 support (although they do help you understand what's actually happening).

   All in all, this is a good book with some detailed coverage of XML and some nice example applications. The first part gives a solid introduction to those without XML knowledge or experience. However, the main thing missing is the lack of real Delphi 6 BizSnap XML coverage (which makes the book "good" but not "very good").