Coding in Delphi

This book collects a number of topics that serve both experienced Delphi developers, and new ones. For experienced developers who got started with Delphi long ago, and who may not have been paying attention to more recent developments in the language, this book efficiently surveys some of the important developments that lead to better code, and shows in a practical way how and why they are useful. For the experienced developer new to Delphi, the topics covered show the Delphi way of handling the language features and programming styles that may be familiar already from other languages. And for the new developer, the author's advocacy and clear demonstration of various valuable software techniques will be welcome encouragement. The book is a useful complement to other broader sources, such as Cantu's Object Pascal Handbook, and the numerous Delphi videos on YT.

Too little has been written on Delphi, these past few years. To borrow from Sam Clemens, the death of the language has been greatly exaggerated. Nick presents a number of the more recent (and not so recent) additions to the Delphi language, and makes plain the advantages in using them. In the matter of interfaces, he harps (and admits it.)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.

Awesome book. Provides us with a lot of advanced concepts in delphi that i had never found in any other source.

Nick was a prior product manager for Delphi and is very well known in the Delphi world. There are good concepts covered here along with reasons to do things.

Excellent book. Too little to be written on Delphi for past few years. The best practice helps me a lot.

Nick Hodges has a clear and easy way of explaining even complex issues. I would definitely recommend this book to anyone who wants to understand coding in Delphi.

If you are looking for a real "hands-on" Delphi book, covering the areas of programming that need attention (best practice coding, etc.) this is a must have.

Nick's book goes through Delphi language features which have been added in the last 5-10 years, particularly Delphi XE2 onwards. It covers many of the same language features described in the excellent Delphi XE2 Foundations book but with a rather different slant. Nick's main focus is on how to use these language improvements to implement modern programming concepts, in particular unit testing. In the process Nick covers new tools which are built on these same language features such as Spring4D, DUnitX and the Delphi Mocks Framework.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?