This book is hands-on, pragmatic, and focused on solving real-world issues.

We’ll begin with a gentle introduction to Delphi for newcomers. You will learn what Delphi is, why it excels at GUIs, and how its free license can get you started. We’ll also touch on its darker history — how Micro$oft nearly brought Delphi down.

Next, we’ll dissect the anatomy of a Delphi project to build our first application. From there, we’ll take a quick tour of the IDE before diving into the Delphi language itself.

We’ll then explore object-oriented programming concepts, including classes, constructors, safe memory management, inheritance, polymorphism, and safe typecasting. You will also learn about visual components and their powerful published properties.

For the adventurous, we’ll delve into advanced abstractions, class methods, class fields, and class constructors. Along the way, we’ll discover what is safe to do in Delphi, what isn’t, and—most importantly—why. 

1. Overview

Intended Audience 3
What is Delphi? 4
Book layout 4
Always focused on code-safety 5
How is this book written? 5
Environment-responsible 6
Who am I? 6
Pre-requisites for this book 7
Let’s start 7

2. Table of content

Symbols and conventions 17

3. What is Delphi?

Delphi is RAD 19
Delphi is general-purpose 19
Delphi has deep roots 20
Delphi = GUI 21
What is the VCL? 23
What is RAD Studio? 24
An IDE with multiple personalities. How does it work? 24
A complete IDE 26
Mature and polished 26
But, it must be expensive… right? 27
What can we build right out of the box, with Delphi? 29
Advantages of Delphi applications 31
Where can we use Delphi? 34
Where can’t we use Delphi? 34
Delphi’s productivity 34
Famous programs built with Delphi 35
Summary 36

4. Delphi today

Popularity 38
About Evil, Darth Vader and… Bill Gates 38
Availability of libraries 39
A brighter future 41
Tiobe Index 42
Summary 44

5. An overview of the Delphi language

Clarity 45
A strongly typed language 46
Well designed 46
One string to rule them all 46
Not open-source 47
Fastest compiler 48
Finally! A compiler that is not snarky 48
No more pointers 50
ASM in the mix 51
Damn fast 51
What kind of applications can we build with Delphi? 52
Why building apps is so easy with Delphi? 53
Delphi is WYSIWYG 53
Quick mockups 53
The VCL framework 53
Low code / no code 54
Portable code 55
Native look 55
Ready for the future 56
The never-ending story 56
Summary 57

6. The Pascal dynasty

Lazarus / FPC 59
Migrating to Lazarus 59
Unitary framework 60
Platforms 61
Compatibility with Delphi 62
Speed 62
C++, Delphi’s cousin 63
Delphi and C++ are binary “compatible” 63
Summary 63
The “Burning Monkey” 64
A bit of history 64
Firemoneky = VCL on steroids 65
Deploying our application on other platforms 67

7. Installing Delphi

Delphi version 70
Time 70
License key 70
ISO installer 70
The installation folder 71
Delphi version info 75
Updates 75
Delphi Silent Installer 76
We are done 76

8. Let’s get started

Anatomy of a Delphi Project 78
Loading a Delphi project into the IDE 78
The DPR file 79
The Project Manager 81
The anatomy of a Delphi unit 84
The “Unit” section 84
The “Interface” and “Implementation” section 85
The chicken and the egg 87
The {$R} section 88
The “Initialization” and the “Finalization” section 88
Project Options 93
Compiler configurations 94
The Manifest file 96
Themes 97
The DProj: DPR’s little brother 99
Project paths 100

9. IDE this… IDE that…

The main menu 104
File 104
Edit 104
Search 104
Refactor 105
Run 105
GExperts and CnPack 105
Project 106
The main panes of the IDE 107
The Project Manager 107
The Component Palette 108
The Object Inspector 108
The Messages window 109
Form designer 109
The Code Editor 109
The Form Designer 112
Common IDE shortcuts 114
Run 114
Run (debug mode) 114
Show (IDE panes) 114
Search 114
Code Editor useful keyboard shortcuts 115
Customizing the IDE 116
Dual monitor 117
IDE Layouts 117
Third party IDE plugins for Delphi 118
DDevExtensions 118
CnPack 119
GExperts 123
Building our own plugins 124
Plugin management 125

10. Our first Delphi application

Smallest Delphi application 127
Let’s start 129
Form = PAS + DFM 134

11. A crash course into the Delphi language

If you already know C++ 136
A typical piece of Delphi code 138
Comments 141
Variables 142
What is a variable? 142
What are data types? 142
Declaring variables 142
General naming conventions in Delphi 144
Naming variables 146
Global versus local variables 147
How do computers store numbers in their memory? 149
Assigning values to a variable 153
Variable initialization 155
Constants 160
Arithmetic operators 161
Data types 163
Primitive Data Types 163
Managed Data Types 173
Delphi is “strong typed” 197
Records 199
Assigning records 201
Field initialization 205
With 210
Displaying a message 212
If/Then/Else 214
Nesting conditions 214
Case 217
Casey’s Coding Conundrum 217
The Quest for Enumerations 217
For loops 220
While 226
Repeat/Until 227
Routines 228
Compartmentalizing your code 228
Reusing the code 229
Procedures 231
Functions 233
Good practice 239
Statement separator 239
How does a computer program work? 240
Nested routines 241
Function overloading 242
Parameters of a routine 243
Not all parameters are created equal 246
Code analysis 252

12. Classes and objects

Why objects? 258
An object 259
Objects vs classes 261
Naming conventions 261
Instantiation 262
Extensibility 262
Constructors 263
Let’s build our own class 264
Inherited 265
Destructors 266
Try/Finally 266
Super-duper important 268
Special cases 268
Fields 270
Properties 271
Read-only properties 274
Recap 274
Published properties 275
Default 276
Objects require manual memory management 277
Pointers 284
Typed vs untyped pointers 284
Dereferencing a pointer 285
Assigning pointers 287
References 291
Dangling references 293
Assigning an object to another object 298
Objects – A real world example 299
Inheritance, polymorphism, and typecasting 301
The inheritance chain 301
Typecasting 303
The hard typecast 306
The ‘as’ typecast 306
The ‘is’ operator 307
Invalid typecasts 308
More invalid typecasts 309
RTTI alternative 311
Methods 313
Method binding 313
Speed 314
Static methods 314
Overriding methods / Polymorphic behavior 316
Polymorphism 319
Hiding vs overriding 323
VMT 325
Overloading methods 326
Declaring multiple constructors with different parameters 331
Keywords recap 334
Recap for polymorphism 334
Methods – Advanced topics 335
Class methods 335
Concrete example 335
Let’s write a better example 337
Class fields 338
Putting class fields to a good use – Singleton class 340
Using it for real 341
Predefined class methods in TObject 342
Abstract methods 344
Abstract classes 348
Generics 349
Creating a generic class 351

13. Forms

PAS + DFM = Form 355
Auto-created forms 357
The main form 358
Secondary forms 359
Stay on top 363
An application without forms 364
The “Application” object 366
Showing a new created form 367
The owner of a form 368
Application as owner 368
Form as owner 368
Nil as owner (no owner) 368
Initialization of a program 369
Closing a form 374
Several ways to close a form 376
Release versus Close 379
Experimenting with Free, Close and Release 380
About GUI Applications 386
So, why do we need GUIs? 386
Let there be mockups! 395
Save GUI state to file 399
Summary 399

14. Visual components

Ownership 402
Parenting 403
Parenting and modularization 405
Ownership vs Parenting 406
Recap 407
Properties of a component 408
Events and event handlers 410
Understanding events 410
Some examples 412
Event handlers are just properties 415
The ubiquitous Sender parameter 416
Building our own visual components 419
Most used visual components 420
TLabel 420
TButton 420
TPanel 421
TRadioButton 421
TCheckBox 421
TImage 422
TEdit 422
TMemo 423
TRichEdit 423
TSpinEdit 424
TTimer 424
More visual components 425
TTrayIcon 425
TFlowPanel 429
TGridPanel 431
Actions / TActionList 434
TActionManager 445
Customizable toolbars 446

15. Databases

FireDAC 453

16. All good things must come to an end

What I have learned in the last 25 years of software development 457
Where do you go from here? 462
Delphi sample projects 462
Your next big project could be a game 463
About Stack Overflow 463
Ask the artificial intelligence 465
Video tutorials 469
Delphi books 469
My books 471
Already published books 471
Next books 471
Notes and credits 473
Appendix 474
Files generated by Delphi 474
Example of ASM code in PAS file: 475
Delphi releases 476
What’s new since Delphi 10.0? 477