procedure WMStuff(var Message: TMessage); message WM_Stuff;

class TMyComponent : public TComponent
{
private:
    int FMyValue;
    void __fastcall SetMyValue(int Value);
public:
    __property int MyValue = { read=FMyValue, write=SetMyValue };
};

4. Поколение программистов пользователей (2000-2020+)

Всё уже написано до нас, хотя на самом деле нет. Но квалификации опровергнуть это утверждения есть не у всех. Вот смотрите, математики могли идти по пути только математиков. Аппаратчики уже могли идти по пути математиков и аппаратчиков. А абстракционисты могли идти по пути математиков, аппаратчиков и абстракционистов. Казалось бы компьютеры стали быстрее и поколение пользователей могли бы идти по пути математиков, аппаратчиков, абстракционистов и пользователей.

Проблема в том, что в каждом поколении есть свои тренды. Если человек начал как пользователь какой-то библиотеки, то ему сложно будет пройти по предыдущим путям. Да и захочет ли он так делать, ведь вызывать готовую функцию всяко проще, чем писать её самому. А даже если и захочет, то появилось куча мусорной литературы. Я бы даже сказал так, поколение программистов пользователей может даже не понимать, что у них в образовании имеются некие проблемы, да и не для всех это действительно проблемы.

Парадигмы программирования
    • Императивная
(контрастирует с декларативной) 
        ◦ Процедурная 
        ◦ Структурная 
        ◦ Аспектно-ориентированная 
        ◦ Объектно-ориентированная 
            ▪ Агентно-ориентированная 
            ▪ Компонентно-ориентированная 
            ▪ Прототипно-ориентированная
        ◦ Обобщённое программирование
    • Декларативная
(контрастирует с императивной) 
        ◦ Чистота языка 
            ▪ Чистота функции
        ◦ Функциональная 
            ▪ В терминах рефал-машины 
            ▪ Аппликативная 
            ▪ Комбинаторная 
            ▪ Бесточечная 
                • (чистая конкатенативная)
        ◦ Логическая 
            ▪ Ограничениями
    • Конкатенативная 
    • Векторная 
    • Метапрограммирование 
        ◦ Языково-ориентированная 
            ▪ Предметно-ориентированная 
            ▪ Пользователями
        ◦ Автоматизация процесса программирования
    • Рефлексивность 
        ◦ Гомоикони́чность
    • Связанные темы 
        ◦ Программирование в крупном и мелком масштабе[англ.] 
        ◦ Модульность 
        ◦ Полиморфизм 
        ◦ Продолжения и CPS 
        ◦ Параллелизм
    • Методы и алгоритмы 
        ◦ Автоматное 
        ◦ Потоков данных 
        ◦ Событийно-ориентированное 
        ◦ Реактивное 
        ◦ Сервис-ориентированное

let people = "Rustaceans";
format!("Hello {people}!");       // => "Hello Rustaceans!"

// Объявление делегата (аналог сигнала)
public delegate void CounterEvent(int newValue);

// Класс, генерирующий событие
class Counter
{
    private int mValue;
    public event CounterEvent Changed; // Аналог сигнала

    public void Set(int v)
    {
        mValue = v;
        Changed?.Invoke(v); // Аналог emit
    }
}

// Класс-подписчик (аналог слота)
class CounterUser
{
    private Counter counter;

    public CounterUser()
    {
        counter = new Counter();
        counter.Changed += CounterChanged; // Аналог connect
    }

    private void CounterChanged(int newValue)
    {
        Console.WriteLine("Counter changed: " + newValue);
    }
}

Qt supports these signal-slot connection types:

— Auto Connection (default) If the signal is emitted in the thread which the receiving object has affinity then the behavior is the same as the Direct Connection. Otherwise, the behavior is the same as the Queued Connection."
— Direct Connection The slot is invoked immediately, when the signal is emitted. The slot is executed in the emitter's thread, which is not necessarily the receiver's thread.
— Queued Connection The slot is invoked when control returns to the event loop of the receiver's thread. The slot is executed in the receiver's thread.
— Blocking Queued Connection The slot is invoked as for the Queued Connection, except the current thread blocks until the slot returns.

Note: Using this type to connect objects in the same thread will cause deadlock.
— Unique Connection The behavior is the same as the Auto Connection, but the connection is made only if it does not duplicate an existing connection. i.e., if the same signal is already connected to the same slot for the same pair of objects, then the connection is not made and connect() returns false.

delegate void CounterEvent(int newValue);

typedef int CounterEvent(int newValue);

using CounterEvent = int(int newValue);

public class AsyncExample  
{  
    // Synchronous methods.  
    public int Method1(string param);  
    public void Method2(double param);  
  
    // Asynchronous methods.  
    public void Method1Async(string param);  
    public void Method1Async(string param, object userState);  
    public event Method1CompletedEventHandler Method1Completed;  
  
    public void Method2Async(double param);  
    public void Method2Async(double param, object userState);  
    public event Method2CompletedEventHandler Method2Completed;  
  
    public void CancelAsync(object userState);  
  
    public bool IsBusy { get; }  
  
    // Class implementation not shown.  
}

If your class needs to provide asynchronous behavior according to the Event-based Asynchronous Pattern Overview, you will encounter a number of concurrency management issues.
Among these is the requirement to ensure that event handlers are called on a thread or context that is appropriate for the application model (for example, Windows Forms applications, ASP.NET applications, console applications, and so on). The AsyncOperationManager provides a convenient way to create a class that runs properly under all application models supported by the .NET Framework.

The completion delegate is the method that the underlying, free-threaded asynchronous behavior will invoke when the asynchronous operation ends by successful completion, error, or cancellation.
This invocation happens on an arbitrary thread.

This method is where the client's task ID is removed from the internal collection of unique client tokens. This method also ends the lifetime of a particular asynchronous operation by calling the PostOperationCompleted method on the corresponding AsyncOperation.
This call raises the completion event on the thread that is appropriate for the application model. After the PostOperationCompleted method is called, this instance of AsyncOperation can no longer be used, and any subsequent attempts to use it will throw an exception.