Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
+ Free Shipping
+ $3.99 shipping
+ $3.75 shipping
Coding in Delphi Paperback – February 22, 2014
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who viewed this item also viewed
About the Author
Nick Hodges has been a part of the Delphi community from the very beginning. He is an original Delphi 1 beta tester, a former member of TeamB, an Advisory Board member for the annual Borland Conference, a frequent conference speaker, a blogger and author of numerous articles on a wide range of Delphi topics. Nick has a BA in Classical Languages from Carleton College and an MS in Information Technology Management from the Naval Postgraduate School. In his career he has been a busboy, a cook, a caddie, a telemarketer (for which he apologizes), an Office Manager, a high school teacher, a Naval Intelligence officer, a software developer, a product manager, and a software development manager. In addition, he is a former Delphi Product Manager and Delphi R&D Team Manager. He lives with his family in Gilbertsville, PA.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Gems in the Book:
- Good Design Principles, with thorough down-to-earth (sometimes, too lengthy) explanation
- Delphi for Spring Focus (it does cover the RTL as well)
- Dependence Injection
1. Lack of Depth ( I concur with one of the reviewers in 2014). It does cover tricks and good practices relevant to the subjects but more in-depth discussion on those subjects seem missing. For example, I found "Delphi in a Nutshell" has more in-depth discussion about interfaces.
2.The book probably can be more concise (or more condensed). Personally I don't like blog-type of folksy narration (but, that is just my personal taste) - and the book appears somewhat too folksy ("for-dummy style"?) in its writing. My favorite writing style is that of "Delphi in a Nutshell", concise and no-nonsense. Again, personal taste.
3. The book is too large in its printed version and typesetting. Don't understand why.
Full disclosure: I participated in the online review process during the writing, and proofread the first full draft. I'm a long-time Delphi developer, and yes, I am biased.
The worst I can say of this book is that I wish Nick had gone a bit deeper in some areas. It should be in your library, and will amply repay your investment in purchase and study.
The result is an excellent and thought provoking introduction to new ways to develop in Delphi. Anyone who hasn't been keeping up with the latest in software development theory and the related Delphi advancements will learn a lot from reading Coding in Delphi.
So why not 5 stars? After all I learned some things I didn't know and came to view several concepts in a different light as a result of reading the book. The problem was that for me the book didn't dig deeply enough and I would have liked Nick to grapple more with some of the tricky questions. Many times while reading it I found myself thinking yes, but what about this problem, side effect or catch 22.
For example Nick tries to build a case for using interfaces heavily for most, if not all, references because, as he points out, this makes for a decoupled design which is comparatively easy to unit test. The obvious problem is that interface and object references don't mix well and using both is likely to lead to AVs. Nick mentions this and suggests you never mix them. This is all very well but by necessity all components, including data access components, are object referenced and freed as objects. So what are we to do? Don't include any components in our unit tests? Or use interfaces from these components to allow easy mocking and just accept that we're going to have to be very careful to nil all interface references before we let the components be freed?
Most of my concerns were along similar lines. It is easy to demonstrate interfaces, mocking, dependency injection, using a service locator just once at the root of the application to build all dependencies, etc in a simple example. It is another to then assume that all of these smoothly scale out to real world complexity without the need for compromises or new approaches.
For all that the book is clearly still a 4 star book and brings a lot to the table in its own right. Perhaps it just needs a more in-depth sequel by Nick or a related party?