The mission

There are many programming languages out there. Most of them brag to be able to create cross-platform applications and to allow you to “easily create rich GUI applications” but miserably fail.

In this book, we will actually achieve true cross-platform GUI applications with code that is 100% portable on Windows, Mac, Android, Linux, etc. I promise it WON’T be a bumpy road!

Your first Hello World application will be a single EXE file, few MB in size that will run on all major platforms without any additional libraries (Java, runtime DLLs, browsers, etc) required.

For whom is this book?

This book is specially written for

• People that have little in programming
• C++ programmers that want to switch to a more productive environment
• Programmers that are advanced but never actually did GUI or cross-platform applications

What you will learn

• What is the best IDE/compiler to develop cross-platform applications (modern, easy, fast, portable)
• Basic programming skills
• How to debug like a pro
• Create GUI applications
• Create less-buggy/more reliable applications
• Advanced debugging techniques

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. 

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

We’ll start with an in-depth look at the Delphi compiler (linker, precompiled libraries, library paths). Then, we’ll move on to advanced debugging: reading call stacks, using advanced breakpoints, remote debugging, and leveraging third-party tools for automated bug reporting and crash data collection. You’ll learn to how to set the compiler to help you pinpoint crashes and even prevent them entirely on your customer’s computer.

Next, we’ll tackle memory management (memory ownership, preventing and dealing with memory corruption) and proper exception handling (covering crashes, access violations, nil pointers, etc). For legacy developers, there’s a section on modernizing old Delphi code for safety, speed, and 64-bit compatibility.

Additional topics include version control, multi-threading, Windows messages, and avoiding common pitfalls like buffer overflows, Application.ProcessMessages, abusing pointers, etc.

I promise that by applying the concepts in this book, your application will run smoothly—without any crashes! 

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

We’ll start by studying the anatomy of a Delphi package and its famous BPL/DCP files. You’ll learn how packages can help organize your code, break circular references, and will do some Zen, studding the four rules of packaging.

Next, we’ll dive into the inner workings of Delphi’s library system (VCL), including how to recompile parts of it — if necessary.

From there, we’ll explore practical techniques: how to design and set up your own library system, leverage precompiled code to dramatically boost compilation speed, and, of course, tackle the ever-important topic of managing library paths.

While building custom visual components isn’t the primary focus, we’ll dedicate a chapter to it with sample code, including discussions about design-time and runtime packages.

Finally, to become true professionals, we’ll venture neck-deep into the gritty details of packages: the linker, package initialization, constructors and destructors, component streaming, component states, debugging packages, and even the IDE itself.

As you can see, no stone was left unturned in this book!