Leanpub Header

Skip to main content
Go to Leanpub.com

Modern Delphi Programming

Building Professional Applications with RAD Studio and Object Pascal

This book is 100% completeLast updated on 2026-08-14
Steve Publications

Master modern Delphi from the ground up and build software that’s ready for the real world. From Object Pascal and VCL to FireMonkey, FireDAC, REST, concurrency and testing, this hands-on guide shows you how to write clean, maintainable applications with RAD Studio 13 Florence, backed by practical examples and proven techniques.

Minimum price

$19.00

$29.00

You pay

Author earns

$

Also available for 1 book credit with a Reader Membership

PDF
EPUB
WEB
APP
379
Pages
About

About

About the Book

This book teaches modern Delphi development from first principles through production-grade architecture. Using RAD Studio 13 Florence as the reference platform, it covers the Object Pascal language, the runtime library, VCL and FireMonkey UI frameworks, FireDAC database programming, REST integration, concurrency, testing, deployment and legacy code modernization. Every concept is explained with complete, compilable examples and practical guidance about when to use each technique, what tradeoffs exist, and which patterns fit real-world Delphi applications best.

Share this book

Categories

DelphiComputers and ProgrammingSoftware EngineeringObject-Oriented Programming

Feedback

Email the Author

Author

About the Author

Steve Publications

Steve is a technology professional with more than 20 years of experience in software development, server infrastructure, cybersecurity, vulnerability research and reverse engineering. Throughout his career, he has designed, secured, analyzed and tested complex software and infrastructure, with a particular focus on understanding how systems fail and how they can be made more secure.

Outside of work, Steve enjoys sharing knowledge with the technology community. He collaborates with researchers, industry experts and technology professionals to write practical books covering software development, cybersecurity, cloud computing, networking, DevOps, artificial intelligence and enterprise technologies. His books focus on practical learning through clear explanations, real-world examples and hands-on exercises. With more than two decades of industry experience, his goal is to help IT professionals, students and technology enthusiasts build useful skills and stay current in a rapidly changing industry.

We believe readers deserve to know how our books are created. Most of our authors are not native English speakers, so we use AI to help translate, proofread manuscripts, fix grammar, improve sentence structure and make technical explanations easier to read. AI is used as an editing tool only. It does not replace the research, technical knowledge or hands-on experience behind our books. Some of our authors also prefer to remain anonymous for privacy or professional reasons. In those cases, we publish their work under a different name. The author's name may be different, but the quality of the content and our review process remain the same.

Every book is written, reviewed and maintained by experienced technology professionals, with contributions from our private technical community of more than 420 engineers and researchers. We spend far more time validating technical accuracy and keeping our content up to date than generating text. We are always interested in working with experienced professionals who have deep expertise in a particular technology or domain. If you would like to publish a book with us or help review an existing manuscript, we'd love to hear from you. Send us a message describing your area of expertise. We are especially interested in niche technologies, specialized skills and emerging topics that are underrepresented in existing technical literature.

If you look through the contents of our books, you'll see practical examples, detailed explanations and material that is regularly updated. Our goal is to publish books that professionals can actually rely on, not low-effort AI-generated content. If you ever feel that one of our books does not meet that standard, Leanpub offers a 60-day money-back guarantee. Feel free to request a refund if you are not satisfied with your purchase.

Contents

Table of Contents

Building Professional Applications with RAD Studio and Object Pascal

Introduction

  1. Why This Book Exists
  2. What You Will Learn
  3. How This Book Is Organized
  4. Prerequisites
  5. Target Platform and Version Notes
  6. Code Examples
  7. When Delphi Is a Strong Fit
  8. A Note on Practice Categorization

Chapter 1: The Delphi Ecosystem Today

  1. What Is Modern Delphi
  2. RAD Studio Editions and Licensing Landscape
  3. Supported Platforms and Target Architectures
  4. The Compiler Model and Native Code Generation
  5. IDE Overview and Workspace Layout
  6. Project Groups, Projects, Units, and Source Organization
  7. Build Configurations, Targets, and Conditional Compilation
  8. Packages: Design-Time vs Runtime
  9. When Delphi Is a Strong Fit (and When It Is Not)
  10. Chapter Summary

Chapter 2: Your First Applications: Tooling Workflow

  1. Installing RAD Studio and SDK Requirements
  2. Creating a Console Application End to End
  3. Creating a VCL Desktop Application
  4. Creating a FireMonkey Cross-Platform Application
  5. The Build Process Explained Step by Step
  6. Running and Debugging: Breakpoints, Watches, Call Stack
  7. Inspecting Variables and Evaluating Expressions
  8. Project Options and Key Settings
  9. Navigating Code: Go to Declaration, Find References, Quick Fix
  10. Chapter Summary

Chapter 3: Object Pascal Language Fundamentals, Part I

  1. Program Structure: Units, Interfaces, Implementations
  2. Constants, Variables, and Scope Rules
  3. Primitive Types: Integers, Floats, Booleans, Characters
  4. Strings and Unicode: AnsiString vs UnicodeString
  5. Enumerations and Subranges
  6. Arrays: Static, Dynamic, Open Array Parameters
  7. Records: Basic Syntax, Methods, and Operators
  8. Sets and Their Practical Uses and Limits
  9. Type Aliases and Strong Typing
  10. Chapter Summary

Chapter 4: Object Pascal Language Fundamentals, Part II

  1. Procedures and Functions: Parameters, Calling Conventions, Overloading
  2. Default Parameters and Named Arguments
  3. Nested Routines and Lexical Scoping
  4. Pointers: Types, Operations, and Safety Considerations
  5. Variants: When They Help and When They Hurt
  6. Anonymous Methods and Closures
  7. Type Helpers for Extension Without Modification
  8. Attributes and Metadata on Types and Members
  9. The Initialization and Finalization Sections
  10. Chapter Summary

Chapter 5: Object Pascal Language Fundamentals: Part III

  1. Classes and Objects: Declaration, Instantiation, Lifetime
  2. Constructors and Destructors: Patterns and Pitfalls
  3. Visibility: Public, Protected, Private, Published
  4. Inheritance, Virtual Methods, Abstract Methods, Polymorphism
  5. Interfaces: Reference Counting, Implementation, Versioning
  6. Properties: Getters, Setters, Stored Values, Notifications
  7. Generics: Type Parameters, Constraints, Reusable Code
  8. Generic Collections from System.Generics.Collections and System.Generics.Defaults
  9. Extended RTTI and Reflection via System.RTTI
  10. Memory Management: Ownership, Manual vs Automatic, Common Leaks
  11. Chapter Summary

Chapter 6: Error Handling, Diagnostics, and Defensive Programming

  1. Exceptions: Raising, Catching, Re-raising, Custom Types
  2. Try-Finally vs Try-Except: When to Use Each
  3. Structured Error Handling in Production Code
  4. Assertions and Design-Time Checks
  5. Logging Fundamentals and Structured Logs
  6. Diagnostic Tools: Memory Tracking, Leak Detection
  7. Defensive Programming Patterns
  8. Coding Standards: Naming, Formatting, Documentation
  9. Chapter Summary

Chapter 7: The Delphi RTL: Essential Utilities

  1. System Unit: Core Routines Every Developer Needs
  2. Dates and Times: TDateTime, TZLocal, Formatting
  3. String Manipulation: SysUtils, StrUtils, Character Operations
  4. Regular Expressions with System.RegEx
  5. Numeric Formatting and Parsing
  6. File System Access via System.IOUtils
  7. Streams: TStream and Its Key Descendants
  8. Text Encodings and Conversion
  9. Chapter Summary

Chapter 8: Data Serialization, Configuration, and Interoperability

  1. JSON Processing with System.JSON
  2. XML Processing with Xml.XMLDoc and Alternatives
  3. Serialization and Deserialization Patterns
  4. Application Configuration: INI, JSON, Registry, Environment
  5. Environment Variables and Process Information
  6. Executing External Processes and Capturing Output
  7. Interoperability with OS Facilities
  8. Chapter Summary

Chapter 9: Object-Oriented Design in Delphi

  1. Encapsulation and Information Hiding
  2. Composition Versus Inheritance: Practical Guidance
  3. SOLID Principles Applied to Delphi Code
  4. Separation of Concerns in Delphi Applications
  5. Dependency Inversion and Abstraction Boundaries
  6. Dependency Injection Patterns and Containers
  7. When OO Complexity Hurts More Than It Helps
  8. Chapter Summary

Chapter 10: Design Patterns for Delphi Developers

  1. Creational Patterns: Factory, Abstract Factory, Builder
  2. Structural Patterns: Adapter, Decorator, Facade, Proxy
  3. Behavioral Patterns: Strategy, Observer, Command, State
  4. Mediator Pattern for Complex UI Coordination
  5. Repository Pattern for Data Access Abstraction
  6. Service Layer and Domain Service Patterns
  7. Anti-Patterns to Avoid in Delphi
  8. Chapter Summary

Chapter 11: Modular Architecture and Reusable Components

  1. Layered Architecture: Presentation, Application, Domain, Infrastructure
  2. Unit Design: Cohesion, Dependencies, Circular References
  3. Domain Models and Application Services
  4. UI Separation: Forms as Thin View Controllers
  5. Reusable Units and Libraries
  6. Plugin Architectures and Extension Points
  7. Versioning and Binary Compatibility Considerations
  8. Chapter Summary

Chapter 12: VCL: Windows Desktop Applications

  1. VCL Architecture: Components, Controls, Messages
  2. Forms, Panels, and Layout Containers
  3. Standard Controls: Buttons, Edits, Lists, Trees, Grids
  4. Actions, Menus, Toolbars, and Navigation
  5. Dialogs and Common File Operations
  6. Graphics, Drawing, and Custom Painting
  7. Application Lifecycle and Message Loop
  8. DPI Awareness and High-DPI Scaling
  9. Localization and Resource Strings
  10. Accessibility Considerations
  11. Chapter Summary

Chapter 13: FireMonkey: Cross-Platform UI Development

  1. FMX Architecture and Rendering Pipeline
  2. VCL vs FMX: Selection Criteria
  3. Forms, Layouts, and Responsive Design
  4. Standard Controls and Platform Variants
  5. Styles, Themes, and Custom Appearance
  6. Graphics, Effects, and Animations
  7. Data Binding in FMX
  8. Application Lifecycle Across Platforms
  9. Platform-Specific Behaviors and Constraints
  10. Mobile Considerations: Touch, Orientation, Notifications
  11. Chapter Summary

Chapter 14: Database Programming with FireDAC: Fundamentals

  1. FireDAC Architecture and Driver Model
  2. Connections: Configuration, Pooling, Security
  3. Queries and Commands: Parameters, Execution Modes
  4. Datasets: TFDQuery, TFDTable, Navigation, Filtering
  5. Transactions: Isolation Levels, Commit, Rollback, Savepoints
  6. Error Handling and Recovery Patterns
  7. SQLite Integration: Setup, Schema, Examples
  8. PostgreSQL Integration: Setup, Schema, Examples
  9. Chapter Summary

Chapter 15: Advanced Database Development

  1. Query Performance: Indexing, Execution Plans, Optimization
  2. Connection Management in Production Applications
  3. Cached Updates and Batch Operations
  4. Concurrency Models: Pessimistic vs Optimistic
  5. Schema Design for Delphi Applications
  6. Database Migrations and Versioning Strategies
  7. Secure Credential Handling
  8. Database-Specific Features and Gotchas
  9. Chapter Summary

Chapter 16: HTTP, REST, and API Integration

  1. HTTP Client Options: TRESTClient, System.Net.HttpClient, Indy
  2. Consuming REST APIs: GET, POST, PUT, DELETE
  3. JSON Serialization Boundaries
  4. Authentication: API Keys, OAuth Concepts, Bearer Tokens
  5. TLS, Certificates, and Secure Connections
  6. Timeouts, Retries, and Resilience Patterns
  7. Rate Limiting and Backoff Strategies
  8. Building Simple REST APIs with Delphi
  9. Chapter Summary

Chapter 17: Networking Fundamentals

  1. Sockets with Indy and Native Components
  2. Client-Server Communication Patterns
  3. Serialization Over the Wire
  4. Security Considerations in Network Code
  5. Chapter Summary

Chapter 18: Concurrency in Modern Delphi

  1. Threads and TThread: Creation, Execution, Lifetime
  2. Thread Safety: Shared State, Race Conditions, Deadlocks
  3. Synchronization Primitives: CriticalSections, Mutexes, Events
  4. Monitors and Higher-Level Coordination
  5. Producer-Consumer Patterns and Queues
  6. TTask and the Parallel Programming Library
  7. Parallel Loops and Futures
  8. Cancellation and Cooperative Termination
  9. UI Thread Synchronization and Background Work
  10. Race Conditions, Deadlocks, Contention: Practical Prevention
  11. Immutable-Data Approaches
  12. Chapter Summary

Chapter 19: Performance Engineering

  1. Profiling Tools and Techniques in RAD Studio
  2. Benchmarking Methodology and Pitfalls
  3. Compiler Optimization Flags and Behavior
  4. Algorithmic Efficiency Considerations
  5. Allocation Costs and Object Pooling
  6. String and Collection Performance Characteristics
  7. Database Performance Review
  8. Concurrency Performance: Lock Contention and Scaling
  9. Chapter Summary

Chapter 20: Professional Windows Development

  1. Calling Win32/Win64 APIs Directly
  2. Windows Messages and Message Handling
  3. COM Interoperability Basics
  4. Windows Services with TService
  5. DLL Creation and Consumption
  6. External Library Linking: C/C++ ABI Compatibility
  7. Callbacks, Marshaling, and Record Layout
  8. Runtime Packages for Windows
  9. Chapter Summary

Chapter 21: Cross-Platform Development Constraints

  1. Supported Platforms Summary and Capabilities Matrix
  2. Conditional Compilation Strategy
  3. Platform-Specific Units and Abstraction Layers
  4. File System and Path Handling Across Platforms
  5. Registry vs Alternatives
  6. Threading Model Differences
  7. GUI Framework Limitations Per Platform
  8. Deployment Considerations Per Target
  9. Chapter Summary

Chapter 22: Building Custom Components and Packages

  1. Component Design Principles
  2. Visual vs Nonvisual Components
  3. Properties, Events, and Persistence
  4. Design-Time Considerations and Editors
  5. Package Creation: BPL Structure and Dependencies
  6. Runtime Packages in Applications
  7. Distributing Components and Libraries
  8. Binary Compatibility Across Versions
  9. Chapter Summary

Chapter 23: Testing with Delphi

  1. DUnitX and the Modern Testing Ecosystem
  2. Unit Testing: Structure, Assertions, Organization
  3. Test Data Management and Fixtures
  4. Mocks, Fakes, and Dependency Isolation
  5. Integration Testing Strategies
  6. Database Testing Approaches
  7. API and Network Testing
  8. UI Testing Considerations
  9. Regression and Legacy Characterization Tests
  10. Running Tests in CI
  11. Chapter Summary

Chapter 24: Source Control, Build Automation, and CI/DCD

  1. Git Repository Organization for Delphi Projects
  2. Branching and Release Practices
  3. Command-Line Builds with MSBuild
  4. Reproducible Builds
  5. Static Analysis and Quality Checks
  6. CI/CD Pipeline Design for Delphi
  7. Environment and Secret Management
  8. Chapter Summary

Chapter 25: Deployment, Packaging, and Signing

  1. Application Versioning Strategies
  2. Windows Installers: Inno Setup, MSIX, Alternatives
  3. Platform Packaging for Non-Windows Targets
  4. Runtime Dependencies and Redistributables
  5. Update Strategies
  6. Code Signing: Certificates, Executables, Installers
  7. Production Release Checklists
  8. Chapter Summary

Chapter 26: Modernizing Legacy Delphi Codebases

  1. Assessing a Legacy Codebase: Risks and Priorities
  2. Compiler and Framework Upgrade Path
  3. Obsolete Libraries and Deprecated APIs
  4. ANSI-to-Unicode Migration Issues
  5. 32-bit to 64-bit Transition: Pointer Sizes and Assumptions
  6. Refactoring Global State and Tight Coupling
  7. Modernizing Legacy Database Components
  8. Updating Networking and Communication Code
  9. Incremental Refactoring with Characterization Tests
  10. Strangler Pattern for Gradual Modernization
  11. Database Modernization
  12. API Integration and Service Extraction
  13. When Not to Rewrite
  14. Chapter Summary

Chapter 27: Real-World Case Studies

  1. Case Study 1: Maintainable VCL Business Application with FireDAC
  2. Case Study 2: Cross-Platform FMX Application with REST Integration
  3. Case Study 3: Concurrent Background Processing Application
  4. Case Study 4: Reusable Library with Custom Components
  5. Architectural Decisions Explained
  6. Chapter Summary

Conclusion: Choosing Delphi for Contemporary Systems

  1. Summary of Delphi’s Strengths and Limitations
  2. Ecosystem Health and Community Outlook
  3. Making Technology Choices for Long-Term Projects
  4. Final Recommendations

References

Get the free sample chapters

Click the buttons to get the free sample in PDF or EPUB, or read the sample online here

Download Sample PDFDownload Sample EPUB

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub