Appendices: Projects, Interview Questions, Cheat Sheet & Study Plan

Capstone projects, interview questions, a Delphi cheat sheet, Delphi for C# / Java / C++ / Python developers, and resources with a study plan.

Appendix A: Capstone Projects

Beginner: Console Grade Book. Records, arrays, loops, procedures, file save/load with TStringList, formatted reports.

Beginner: VCL Calculator and Unit Converter. Event handling, case, validation, TActionList, VCL Styles.

Intermediate: Customer Management (VCL + FireDAC + SQLite). Data module, TDBGrid/TDBNavigator, master-detail orders, search/filter, calculated fields, FastReport invoice.

Intermediate: Note-Taking App (FMX, cross-platform). TListView, TMultiView, LiveBindings, SQLite storage in TPath.GetDocumentsPath, Windows + Android builds.

Intermediate: REST Weather Client. TRESTClient/TNetHTTPClient, JSON parsing, async requests, caching, a Skia-drawn temperature chart.

Advanced: Inventory REST API (Horse or DMVCFramework) + VCL/FMX client. JWT auth, FireDAC with PostgreSQL, JSON DTOs (TJsonSerializer), Swagger, DUnitX tests, Windows service deployment.

Advanced: Multithreaded File Processor. TParallel.For and TTask pipelines, TThreadedQueue, progress reporting with TThread.Queue, cancellation, logging.

Advanced: Custom Component Package. A design-time + runtime package with a custom-drawn gauge control, property editor, events, HighDPI support, installed in the IDE.

Advanced: Plugin-Based Application. Runtime packages (LoadPackage) or DLLs with interfaces, RTTI attributes for plugin metadata, a Spring4D DI container.

Mobile: Field Survey App (FMX Android/iOS). Camera, GPS (TLocationSensor), offline SQLite storage, sync with a REST server, permissions handling, push notifications.

Modernization: Legacy Delphi 7 App Upgrade. Migrate BDE → FireDAC, ANSI → Unicode, 32 → 64-bit, add tests and CI, and document the changes.

Appendix B: Interview Questions

What is the difference between a program, a unit, and a package in Delphi?

What goes in the interface vs implementation sections? What are initialization/finalization?

Explain value parameters vs var, const, and out.

Why does a semicolon before else cause an error?

Static vs dynamic arrays? Why are dynamic arrays reference types?

How are strings implemented (reference counting, copy-on-write, 1-based indexing)?

What is the difference between div and /?

Why do you need parentheses in if (A > 0) and (B > 0)?

Record vs class? What are advanced records?

What are sets, and where does the VCL use them?

Explain virtual, dynamic, override, abstract, reintroduce, and overload.

What's the difference between private and strict private?

What does published do?

Why must destructors be override and call inherited?

Free vs Destroy vs FreeAndNil?

What are class methods, class vars, and class constructors? What is static?

What are class references (metaclasses), and how does Application.CreateForm use them?

How do interfaces manage memory? What problems does mixing object and interface references cause?

What is [weak] used for?

What are class/record helpers, and what is their main limitation?

Explain Owner vs Parent in VCL components.

How do events (of object) differ from anonymous method references (reference to)?

How do generics work in Delphi? What constraints are available?

How do anonymous methods capture variables?

What is RTTI? How do custom attributes work?

What are custom managed records, and what can you build with them?

How does operator overloading work, and on which types?

How do you safely update the UI from a background thread?

TThread vs TTask vs TParallel.For?

Which synchronization primitives do you know?

How do you prevent memory leaks? How do you detect them?

What is FireDAC? How do you prevent SQL injection?

Explain cached updates and array DML in FireDAC.

VCL vs FMX: when do you choose each?

What are LiveBindings?

How do you consume a REST API in Delphi?

How would you build a REST server in Delphi?

How do you create a custom component and register it in the IDE?

Runtime packages vs design-time packages?

What issues arise when migrating from Delphi 7 to modern Delphi (Unicode, 64-bit)?

Reverse a string and check whether it's a palindrome (handling the 1-based index).

Implement a generic TStack<T> with exception handling for an empty stack.

Count word frequencies in a text file using TDictionary<string, Integer>.

Write a class hierarchy (TShape → TCircle, TRectangle) with a polymorphic Area.

Implement an interface-based logger with console and file implementations.

Load a CSV into a TFDMemTable and display it in a TDBGrid.

Download 3 URLs in parallel with TTask and report the total size on the UI thread.

Write a record helper for TDateTime with IsWeekend and AddBusinessDays.

Appendix C: Delphi Cheat Sheet

F9 / Ctrl+F9 / Shift+F9 Run / Compile / Build Step into / Step over / Toggle breakpoint Toggle form/code / Object Inspector

Jump between declaration and implementation Ctrl+Space / Ctrl+J Code completion / Templates Insert a new GUID

// ===== Structure =====
program App; {$APPTYPE CONSOLE} uses System.SysUtils; begin Writeln('Hi'); end.
unit U; interface uses ...; type ...; implementation ... end.

// ===== Variables & types =====
var I: Integer; S: string; D: Double; B: Boolean; C: Currency;
var X := 10;                              // inline + inference (10.3+)
const Max = 100;
type TColor3 = (Red, Green, Blue); TSet = set of TColor3; TArr = TArray<Integer>;

// ===== Control flow =====
if (A > 0) and (B > 0) then ... else ...;
case N of 1: ...; 2..5: ...; else ...; end;
for I := 1 to 10 do ...;  for I := 10 downto 1 do ...;  for var E in List do ...;
while Cond do begin ... end;  repeat ... until Cond;
Break; Continue; Exit; Exit(Value);

// ===== Routines =====
procedure P(const S: string; var N: Integer; out R: Double; X: Integer = 0);
function F(A, B: Integer): Integer; begin Result := A + B; end;
function G(const Arr: array of Integer): Integer; overload;

// ===== Classes =====
type
  TFoo = class(TBase, IBar)
  strict private
    FValue: Integer;
    procedure SetValue(const V: Integer);
  public
    constructor Create; override;
    destructor Destroy; override;
    procedure DoIt; virtual;
    proper
…

Appendix D: Delphi for C# / Java / C++ / Python Developers

begin... end Assignment / equality string (1-based) class Foo: Base class Foo extends Base class Foo: public Base class Foo(Base) TFoo = class(TBase) constructor Create destructor Destroy; override; interface IFoo interface Foo IFoo = interface [](int x){...} lambda x: x * 2

function(X: Integer): Integer begin Result:= X * 2 end try/except and try/finally (nested)

Manual (Free) + refcounting for strings/interfaces { get; set; }

property X: Integer read FX write SetX; of object method pointers GetIt / Boss / DPM Key gotchas:

C#/Java devs: there's no garbage collector for objects (always Free), strings are 1-based, := assigns, and there's no try..catch..finally combination.

C++ devs: objects are always heap references (no stack objects of class type), there's no multiple inheritance (use interfaces), and units replace headers.

Python devs: Delphi is statically typed and compiled, and it uses begin..end blocks and semicolons.

Appendix E: Resources and Study Plan

Embarcadero DocWiki (docwiki.embarcadero.com): language guide, RTL/VCL/FMX reference, FireDAC docs

Embarcadero Blogs, Learn Delphi (learndelphi.org), Embarcadero Academy, the CodeRage conference videos, the official YouTube channel, GetIt samples

Community: Delphi-PRAXiS forum (en.delphipraxis.net), Stack Overflow (delphi tag), r/delphi, Delphi Developer groups, DelphiFeeds, Delphi Weekly

*Object Pascal Handbook* by Marco Cantù (free for registered users; the definitive language guide)

*Mastering Delphi* series by Marco Cantù (classic) *Delphi Memory Management for Classic and ARC Compilers* by Dalija Prasnikar

*Delphi Event-based and Asynchronous Programming* by Dalija Prasnikar

*Coding in Delphi* and *More Coding in Delphi* by Nick Hodges (generics, interfaces, DI, unit testing)

*Dependency Injection in Delphi* by Nick Hodges *Delphi High Performance* by Primož Gabrijelčič

*Hands-On Design Patterns with Delphi* by Primož Gabrijelčič

*Delphi Cookbook* by Daniele Spinetti & Daniele Teti *Fearless Cross-Platform Development with Delphi* by Paweł Głowacki

*Delphi GUI Programming with FireMonkey* by Andrea Magni 14-Week Study Plan IDE, program/unit structure, data types

Operators, control flow, routines, strings Arrays, records, enums/sets, pointers, variants, exceptions Classes, properties, inheritance

Interfaces, helpers, events, memory ownership Generics, collections, anonymous methods

RTTI/attributes, operator overloading/managed records, directives

Threads, PPL, synchronization, files/streams, WinAPI/DLL/COM VCL fundamentals and advanced topics

FMX, mobile, LiveBindings, Skia/graphics FireDAC, datasets, JSON/XML REST clients, servers, networking

Components/packages, DUnitX, debugging/profiling 48–50 + Capstone

Patterns/architecture, deployment/CI, best practices/migration

Final tip: Master object ownership and try..finally first (it's the foundation of reliable Delphi code). Keep business logic in UI-independent units, use interfaces and generics for clean design, and learn FireDAC well. Combine that with VCL for Windows or FMX for cross-platform, and Delphi lets you ship fast, native applications everywhere. Happy coding! 🏛️