Profile for Bob Swart > Reviews


Bob Swart's Profile

Customer Reviews: 4
Top Reviewer Ranking: 26,745,828
Helpful Votes: 46

Community Features
Review Discussion Boards
Top Reviewers

Guidelines: Learn more about the ins and outs of Your Profile.

Reviews Written by
Bob Swart RSS Feed (The Netherlands)

Page: 1
Kylix: The Professional Developer's Guide and Reference
Kylix: The Professional Developer's Guide and Reference
by Jon Shemitz
Edition: Paperback
23 used & new from $1.83

10 of 11 people found the following review helpful
4.0 out of 5 stars Kylix Reference (but without Database or Internet coverage), October 8, 2002
When I received this book, I was impressed by the fact that it contained 943 pages on Kylix - without covering any database or internet development. Now that I finished the book, I'm even more impressed. Not by what's not in the book, but by what's actually covered in the book.
Somehow, the book reminds me of the years I spent at the University of Amsterdam (back in 1983), and first learned to work with UNIX and Minix.
I'm not sure why. Maybe the fonts, maybe the quality. But one thing is for sure, like the cover said: this is not a Delphi book 'ported' to Kylix. This
is a true Kylix/Linux Development book, and as such, I'm sure every Delphi developer can learn something from it.
The book consists of four sections, and a number of appendices. The first section contains about 250 pages about Object Pascal. But before we
start the first section, there's chapter 0: Hello Kylix, in which the author explains why Kylix is great, and what this book will offer (and what not -
so you'll know right away). It also explains where to download the sample code, and then continues with a first hands-on getting started tour in
The first real section of the book consists of four chapters (252 pages) and is about Object Pascal. From data types and datastructures to program
syntax and structure. As a Delphi developer, it was the 'least interesting' section of the book to read, although I would still recommend browsing
through the pages, since there are numerous tips or footnotes that are worthwhile to read (as the back cover says: "even long-time Delphi
programmers will find some surprising details here", such as the part on libraries and dynamic linking). In fact, it reminded me of the excellent Pascal
textbooks I read during my study (mentioned before), and I can recommended it to anyone who wants to learn Object Pascal.
The second section of the book extends the 'simple' Object Pascal languages and moves on to Kylix - the RAD Development environment on Linux.
In five chapters, we'll learn how to use Kylix (the IDE, designing, debugging), and the components that can be used with Kylix. When I say
components, the author has split them in a few different chapters. First, we get the Visual Objects (VisualCLX components on top of Qt), followed
by a chapter about Foundation Objects (the non-visual components and support classes such as collections and streams, as well as threads), and
finally library routines (only the most important ones, like Strings, Dates, Maths, etc.), and component building in Kylix. Although - like I mentioned
before - this is not a Kylix 'port' of a Delphi book, the author does place 'cautions' and notes in the chapter to highlight some of the differences
between Delphi and Kylix that are important to Delphi developers. The repeated reminder in the border that keeps telling us that "Kylix is not Delphi"
grows a bit tiresome after a while, but the notes themselves are good points.
The third section of the book is about Linux - for Windows developers, and using Kylix. It covers Linux and Linux programming from a Windows
programmer's perspective, explaining the differences, and showing what to do (and how to do it differently) under Linux. Subsections include files,
memory, processes, regular expressions and scripts (this brought back some fond memories when I first used UNIX almost two decades ago). The
final chapter in this section introduces X and Qt (we've seen Qt before in the previous section). It's only a short chapter, which is good, since I
consider this only background information (to give an architectural overview of X and Qt). VisualCLX is build on top of Qt (and X) and in theory you
should seldom have to sink down to the API level.
The fourth section of the book is about entire projects, and contains two chapters: one about a visual find utility (imitating Windows' Find Files),
and a chapter on Mandelbrot 4 (I wasn't too interested in this, but the results look very nice).
Fortunately, the book wasn't finished after this last chapter, since we still have a number of interesting appendices. Covering topics such as "Kylix
for Visual Basic programmers" (there may be more than you think), "Kylix for Delphi programmers" (a bit late if you read the entire book already, but
it gives a short summary of the most important changes and gotchas, including references to chapters that cover these in more detail). So Delphi
developers may want to start reading the book with Appendix II. Other appendices cover topics like Optimization and a BASM quick reference,
although these two are too short to be of real use I'm afraid. Appendix V on Deployment is a whole lot better, especially since this is indeed an ever
returning Kylix developer's FAQ. Well written, and helpful for deployment on systems that don't have Kylix installed.
Apart from the regular text, the book contains numerous little "notes" that contain tips, background information or just useful techniques worthy to
highlight. The index seems complete, but could use a smaller font to get a better overview. Syntax highlighting is used in source code listings,
which I always consider to be very helpful. Unfortunately, on a few places it was missing or inconsistent (just as I sometimes didn't agree with the
source code indentation and layout, but these are personal feelings of course).
Back in the beginning of the book, in Chapter 0, the author explains that he wants to write a 'classic' book. The book that a bookstore would carry
if it had only one Kylix book. I'm not sure if this book is the classic Kylix book (not without database or internet coverage), but it sure is a great
book to learn Kylix as well as Linux - for everybody!
And when it comes to the missing sections (on database and internet): I can also recommend Delphi/Kylix Database Development by Eric Harmon, as well as the Kylix Developer's Guide (for which I wrote the web development chapters).

Advanced Delphi Developer's Guide to Ado with CDR
Advanced Delphi Developer's Guide to Ado with CDR
by Alex Fedorov
Edition: Paperback
29 used & new from $1.48

1 of 1 people found the following review helpful
4.0 out of 5 stars Not only about ADO, June 5, 2002
Based on the title of this Delphi and ADO book: Advanced Delphi Developer's Guide to ADO, I expected "only" coverage of ADOExpress in Delphi. However, that's only a part of this book. The book consists of 23 chapters, starting with the Microsoft Data Access Components (MDAC), OLE DB Providers, ADO and its role in the Delphi Database Architecture. ADOExpress components like TADOCOnnection, TADOCommand, TADODataSet etc. are covered in a lot of detail - as expected. However, apart from these "basics", the book also contains chapters that explain how to actually build ADO Applications, and how to do Business Graphics and Reporting with ADO. Even after those chapter, we're only still halfway the book.
Further topics include OLAP and ADO, ADOX in Delphi, JRO Objects, and a very helpful chapter on deploying ADO applications. Chapter 19 and later introduce Distributed Computing; Windows DNA (Distributed interNet Applications), including RDS and MTS with ADO. There's even a chapter on MIDAS ADO Applications.
There are also a number of appendices; and the most interesting one covers BDE to ADO migration issues!

Tomes of Delphi: Alogrithm and Data Structure (Wordware Delphi Developer's Library)
Tomes of Delphi: Alogrithm and Data Structure (Wordware Delphi Developer's Library)
by Julian Bucknall
Edition: Paperback
23 used & new from $8.00

11 of 11 people found the following review helpful
5.0 out of 5 stars Worth the wait!, June 5, 2002
This is a book that I've been waiting for for a long time (according to the acknowledgements, Julian has worked on it from April 1999 until February 2001, probably even longer). But it has been worth it, because it's an excellent book about algorithms and data structures implemented in Delphi (and Kylix) - usually version independent.
The book consists of 12 chapters. But even before the first chapter Julian takes on the question of "why a book on Delphi algorithms?" in the introduction. He explains that a number of Computer Science algorithms books are hardly practical, and the practical books are mainly for C, C++, or Java. This is a book about algorithms and data structures using Delphi (for Windows, but also Kylix for Linux), with a lot of focus on practical and useful techniques that make sense.
A great plus is that the code in the book works for every version of Delphi and Kylix (and probably also in C++Builder), and I'm fairly confident it will remain working in the next version(s) of Delphi and Kylix to come. A bonus point is the syntax high-lighting in the source code listings. A small effort for the author/publisher, but a great help for the reader who sees the source code for the first time.

Delphi Developer's Guide to XML (Wordware Delphi Developer's Library)
Delphi Developer's Guide to XML (Wordware Delphi Developer's Library)
by Keith Wood
Edition: Paperback
27 used & new from $2.45

24 of 25 people found the following review helpful
4.0 out of 5 stars About XML, but not Delphi 6 BizSnap, June 5, 2002
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").

Page: 1