▶ YouTube Summaries

• https://www.youtube.com/watch?v=4vcA7yJMoPg
• Original title: IDE we forgot about

Tsoding (Alexey Kutepov) revisits Lazarus, the open-source, cross-platform clone of Borland's Delphi 7 IDE built on Free Pascal, lamenting that the "what you see is what you get" visual RAD paradigm of the 90s/2000s has been abandoned in favor of hand-writing HTML/CSS. Over a ~2.5 hour live stream he installs Lazarus on Void Linux, fights its multi-window UI inside the i3 tiling window manager, and builds a native GUI to-do app from scratch — drag-and-drop widgets wired to Pascal event handlers. Along the way he wrestles with dark-theme configuration, list-box selection APIs, logging, and attaching per-item data objects, while repeatedly mocking AI chatbots ("clankers") and modern search engines for giving confidently wrong answers. He concludes the visual RAD model is genuinely great for beginners and kids, remains fast and snappy, and shouldn't have died out.

Premise: a lost paradigm of UI programming

Tsoding introduces Lazarus, an open-source cross-platform IDE that clones Borland Delphi 7 and uses Free Pascal (specifically targeting the look/feel of Delphi 6/7). His thesis: the "what you see is what you get" visual RAD approach — drop a button on a form, double-click it, write the callback — was awesome, easy even for non-programmers, and inexplicably got "downgraded" to writing HTML/CSS by hand. Lazarus aims to be a drop-in replacement for Delphi so old projects can be back-ported to Linux.

Installation struggle on Void Linux

He first tries the official build, downloaded as .deb packages from SourceForge, and complains there is no self-contained tarball (praising Godbolt/Compiler-Explorer-style single static executables). He experiments with dpkg unpacking and xdeb conversion, hits missing GTK/Qt dependencies, and gives up on the official build. He falls back to the Lazarus package already available in the Void repositories, which installs system-wide and works. The build depends on Qt5 for its GUI.

First look and the tiling-window-manager problem

Lazarus opens as several separate floating windows (object inspector, source editor, form designer) in the old Delphi style. Under his i3 tiling WM this is a mess, so he moves the floating windows onto dedicated virtual desktops to recover the intended layout. He reminisces that this is essentially his second-ever IDE — he started programming in 2006 with Visual Basic 6, then Delphi 7 — pushing back on viewers who assume he dislikes IDEs or only recently started coding.

Hello World

He places a button on a form, double-clicks to generate a click handler, and calls MessageDlg. He fights the API signature (dialog type, button set, help context as LongInt), consults Delphi docs, and eventually gets a working "hello / world" information dialog with an OK button — demonstrating Ctrl+click go-to-definition and real autocompletion.

Saving and building the project

He saves the project (LPI project file, LPR main file, .pas unit, backups) and builds it into a native 64-bit ELF executable that dynamically links Qt. Runs standalone as a real GUI app. He marvels that this whole "place elements, add logic, get an executable" workflow has vanished, joking that the code-generation from the visual designer is basically "an agent that writes code for you" — a pitch you could sell to clueless VCs.

Building a to-do app: list box, add/delete

Chat suggests a to-do list. He adds a TListBox, learns items are added via ListBox1.Items.Add(string, nil) (Pascal uses nil, not null). He renames the button to ButtonAdd with a "+" caption and notes the designer auto-renames the field and method throughout the code. He adds a ButtonDelete ("-"), hits a gotcha where copy-pasting a button shares the original's OnClick handler (must clear the event and re-generate), and wires deletion via ListBox.DeleteSelected. He praises this as Lego-like and ideal for kids and beginners.

Edit field and adding tasks on Enter

He adds a TEdit whose .Text (a TCaption, which resolves to a translated string) feeds Items.Add. To add on Enter he uses the OnKeyPress event, discovers the key char, uses Ord/IntToStr to print it, finds Enter = 13 (Windows CR convention, since Lazarus mimics Delphi/Windows), and calls ButtonAddClick passing the generic TObject Sender. He also clears the edit field after adding. He explains Pascal's begin/end blocks and the single-statement then branch.

Fighting the dark theme (~1 hour in)

The default light theme "flashbangs" the viewers. He installs qt5ct, sets the QT_QPA_PLATFORMTHEME=qt5ct environment variable to launch Lazarus, and hunts through Tools > Options > Editor colors. After much frustration he finds the near-invisible preset dropdown and picks the "Twilight" color scheme, finally getting a dark editor.

Memo body, disabling fields, labels

He plans richer tasks: a subject (TEdit) plus a multi-line body (TMemo, whose content lives in .Lines, a TStrings, or the single .Text field). He disables (Enabled=false) the subject and memo until a task exists, adds TLabel captions ("subject", "body", "tasks"), and renames components to meaningful names (SubjectEdit, MemoBody, ListTasks) — again noting automatic propagation of renames.

Logging and selection API — the recurring "clanker" fight

Regular Pascal WriteLn output is swallowed, so he finds View > Debug Windows to see console output. He wants a "get selected item" that returns something null-able (an optional/pointer), but the TListBox only offers GetSelectedText and a Selected[] array, seemingly forcing manual iteration. Chatbots and a chat user ("Spiritman") confidently insist he must iterate; he angrily sub-modes/times-them-out, then discovers ItemIndex (which is -1 when nothing is selected) — exactly the API he wanted — vindicating himself against the confidently-wrong AI answers.

Synchronizing the form and attaching data

He factors the update logic into a SyncTaskForm procedure called on selection change, clicks, add, and delete. He attaches per-item data by passing a TStrings object to Items.AddObject, inspects objects via ClassName, and experiments with GetDelimitedText/DelimitedText for serializing the memo lines (delimiter defaults to comma). During the live session he doesn't fully get the body persistence working and decides it needs deeper knowledge of the framework, stopping after ~2.5 hours feeling mentally drained (largely from fighting the non-tiling UI under i3).

Rants: search engines and AI

Throughout, he rails against Google and modern search engines, arguing they are intentionally nerfed to be unsearchable so users are funneled into AI chat modes ("stochastic parrots") that scrape and re-host website data to steal traffic. He insists older search was as good or better, and that tech companies hate millennials/older users who "remember when it was good" and can't be gaslit.

Outro and footnote: refactor to a proper class

In the closing footnote (recorded after the stream), he says he over-complicated the body storage during the live session. He introduces a proper class — type Task = class(TObject) with a public Body: string field (Delphi "T" prefix convention) — creates a Task per item via AddObject, casts the item's object back to Task on selection, and syncs subject (stored in the list item caption) and body (stored on the Task). He assumes DeleteSelected also frees the associated object (noting Delphi's semi-manual memory management and poor documentation), gets add/edit/delete of subject+body working, and leaves file persistence as out of scope.

Reflections

He closes praising Lazarus as fun, fast, snappy, and reliable in a way modern software isn't, and a great on-ramp for beginners and kids. He notes lots of legacy Delphi 6/7 software still exists (many jobs in Russia; some projects auto-converting Delphi-to-Lazarus), likens it to the COBOL situation, and muses that the industry keeps reinventing languages instead of improving existing ones — citing the "we only need C and Python" take without fully endorsing it.