№ студента	Номера докладов
1	1, 28, 55, 82
2	2, 29, 56, 83
3	3, 30, 57, 84
4	4, 31, 58, 85
5	5, 32, 59, 86
6	6, 33, 60, 87
7	7, 34, 61, 88
8	8, 35, 62, 89
9	9, 36, 63, 90
10	10, 37, 64, 91
11	11, 38, 65, 92
12	12, 39, 66, 93
13	13, 40, 67, 94
14	14, 41, 68, 95
15	15, 42, 69, 96
16	16, 43, 70, 97
17	17, 44, 71, 98
18	18, 45, 72, 99
19	19, 46, 73, 100
20	20, 47, 74, 101
21	21, 48, 75, 102
22	22, 49, 76, 103
23	23, 50, 77, 104
24	24, 51, 78, 105
25	25, 52, 79, 106
26	26, 53, 80, 107
27	27, 54, 81, 108

№ студента	Номера докладов
1	1, 28, 55, 82
2	2, 29, 56, 83
3	3, 30, 57, 84
4	4, 31, 58, 85
5	5, 32, 59, 86
6	6, 33, 60, 87
7	7, 34, 61, 88
8	8, 35, 62, 89
9	9, 36, 63, 90
10	10, 37, 64, 91
11	11, 38, 65, 92
12	12, 39, 66, 93
13	13, 40, 67, 94
14	14, 41, 68, 95
15	15, 42, 69, 96
16	16, 43, 70, 97
17	17, 44, 71, 98
18	18, 45, 72, 99
19	19, 46, 73, 100
20	20, 47, 74, 101
21	21, 48, 75, 102
22	22, 49, 76, 103
23	23, 50, 77, 104
24	24, 51, 78, 105
25	25, 52, 79, 106
26	26, 53, 80, 107
27	27, 54, 81, 108

синтаксис языка Си (с опорой на классический учебник Кернигана и Ритчи) в сравнении с Go и Python:

Учебный доклад демонстрируется аудитории на доске непосредственно в формате обычного документа Word без титульного листа (для исключения галлюцинаций ИИ, если вы их используете необходимо добавлять скриншоты из конкретных учебников с подписью источника под картиной, скриншот разместить в тех же ячейках таблицы) и должен содержать подробную сравнительную инструкцию в виде таблицы из трех колонок: первая — Go, вторая — Си, третья — Python. В рамках отчета необходимо выбрать конкретную часть языка (то есть раскрыть тему доклада, что вам выдана), дать её развернутое описание, выделить ключевые сходства и отличия между этими тремя языками, а также глубоко раскрыть, как именно этот высокоуровневый механизм для Go и Python физически реализован «под капотом» на базовом уровне языка Си, обязательно сопроводив теоретический материал наглядным примером такой Си-реализации и фрагментом практического использования этой конструкции в коде. А также привести примеры использования на каждом языке в соответствующей колонке.

Таким образом в докладе должны быть продемонстрированы: синтаксис на всех трех языках, примеры использования на всех трех языках; как реализовать возможность на каждом из двух других языков того, что реализовано на третьем языке, если там что-то высокоуровневое и уникальное: на одном языке может быть одна строчка, а на другом объемный код; а также обязательно как рассматриваемые элементы из Питон и Го реализованы в интерпретаторе(или компиляторе) на Си, или как их можно реализовать, если не найдется статья подходящая.

В тексте доклада должны присутствовать скрины листингов программ из источников.

Для частей доклада в соотвествии с приказом ...777.... необходимо указать в соответствующих частях какие ИИ использовались при подготовке этой части текста и какие конкретно использовались промпты.
Сами страницы общения с ИИ с ответами желательно (но необязательно) тоже приложить в формате mhtml

Ссылки указываются в неотформатированном виде (ссылка из адресной строки браузера как есть) или данные источника с второй страницы книги.

Доклады должны быть достаточного объема чтобы докладывать его 10 минут и содержать дополнительные материалы или избыточный объем, чтобы при необходимости докладывать 30 минут.

Доклады демонстрируются всей группе на экране с проектором и освещаются выступающим.

Доклад сделан не только для того, чтобы сдать его и получить зачет, а прежде всего для того, чтобы друг друга научить - поэтому доклады необходимо готовить вовремя по 1 каждую неделю, а также доклады необходимо внимательно слушать, задавать вопросы. А студенты отсутствующие на соотвествующих семинарских занятиях рискуют получить дополнительные вопросы по всем пропущенным докладам.

Размер шрифта в примерах кода должен примерно соотвествовать размеру всего остального текста на странице.

ОБЯЗАТЕЛЬНО ДЛЯ ЭТОГО И СЛЕДУЮЩИХ ДОКЛАДОВ

Не требуется оформлять презентацию. Достаточно хорошо отформатированного для отображения на проекторе Word (6 кегль шрифт, 1 интервал, 0 интервал между абзацами, шрифт Tahoma, междустрочный интервал 1) и копию экспортом в Pdf документ, на случай, если слетит форматирование.
Обязательно помимо раскрытия темы привести ниже или в тексте скрины страниц из источников (учебников с обязательным приложенным скрином обложки и выходных данных) и документцаии производителя.
Если требуется перевод (можно пользоваться яндекс переводчиком документов pdf), то привести скрины и на языке оригинала и переведенного рядом, чтобы можно было сопоставить. Для интернет источников необходимы ссылки (это касается документации производителя) на страницы.
Если для источников допустимо распространение, то приложить и сами источники, чтобы можно было их полистать во время доклада.

В тексте доклада должны присутствовать скрины листингов программ из источников.

Для частей доклада в соотвествии с приказом ...777.... необходимо указать в соответствующих частях какие ИИ использовались при подготовке этой части текста и какие конкретно использовались промпты.
Сами страницы общения с ИИ с ответами желательно (но необязательно) тоже приложить в формате mhtml

Ссылки указываются в неотформатированном виде (ссылка из адресной строки браузера как есть) или данные источника с второй страницы книги.

Доклад должен содержать большое количество примеров, один пример из трех колонок должен представлять из себя скрин из учебника или документации производителя (с указанием источника под скрином мелким шрифтом), а аналоги на других языках этого кода можно сгенерировать в ИИ. Скрины должны быть представлены в одинковом количестве для всех трех колонок, то есть чередуйте (сначала скрин в 1 примере для первого языка, далее во 2 примере для уже другого второго языка, далее в следующем примере для третьего языка и так и далее). Примеры должны быть идентичные на всех трех языках (одни и теже значения, имена переменных и тд), чтобы мы могли сосредоточиться на отличиях. А сами примеры должны располгаться в одной строчке, чтобы не искать глазами на экране аналогичный пример, а видеть его сразу слева и справа.

Доклады демонстрируются всей группе на экране с проектором и освещаются выступающим.

Доклад сделан не только для того, чтобы сдать его и получить зачет, а прежде всего для того, чтобы друг друга научить - поэтому доклады необходимо готовить вовремя по 1 каждую неделю, а также доклады необходимо внимательно слушать, задавать вопросы. А студенты отсутствующие на соотвествующих семинарских занятиях рискуют получить дополнительные вопросы по всем пропущенным докладам.

ПЕРВЫЙ ДОКЛАД

Темы докладов ниже пронумерованы цифрами (для групп где 17 человек) с пояснением (а для других групп в конце страницы ищите список):

1. Точка входа и базовая структура программы

Go: Программа начинается с `package main` и функции `func main()`.

Си: Выполнение начинается строго с функции `int main(void)` или `int main(int argc, char argv[])`. Для использования библиотек требуется директива `#include`.

Python: Точка входа определяется условно (часто через `if name == "main":`). Файл выполняется интерпретатором сверху вниз.

2. Блоки кода и разделители

Go: Блоки выделяются фигурными скобками `{}`. Точки с запятой компилятор расставляет сам.

Си: Блоки выделяются фигурными скобками `{}`. Точка с запятой `;` является обязательным признаком конца оператора.

Python: Блоки выделяются исключительно отступами. Символы `;` и `{}` не требуются.

3. Объявление переменных и вывод типов

Go: Тип пишется после имени. Доступен короткий оператор автоматического вывода типа `:=`.

Си: Строгая статика: тип всегда пишется строго перед именем переменной (например, `int x = 5;`). Короткого вывода типов нет.

Python: Динамическая типизация. Переменная создается в момент присваивания значения.

4. Базовые типы данных

Go: Встроенные типы `int`, `float64`, `bool`, `string`, `rune` (для символов).

Си: Базовый набор включает `char` (символ, 1 байт), `int`, `float` и `double`. Исторически встроенного логического типа нет — используется `int` (0 — ложь, ненулевое значение — истина).

Python: `int` (числа неограниченной длины), `float`, `bool`, `str`.

5. Константы и препроцессор

Go: Используется встроенное ключевое слово `const`.

Си: Программа проходит этап препроцессинга до компиляции. Константы часто задаются через директиву текстовой замены `#define` (например, `#define PI 3.14`).

Python: Механизма неизменяемых констант нет, используются соглашения (имена пишутся ЗАГЛАВНЫМИ_БУКВАМИ).

6. Операторы, выражения и инкремент

Go: Инкремент (`x++`) является отдельной инструкцией, а не выражением.

Си: Операторы инкремента (`++`) и декремента (`--`) могут быть как префиксными, так и постфиксными, и встраиваться напрямую внутрь сложных математических выражений.

Python: Для логики применяются слова `and`, `or`, `not`. Операторов `++` и `--` не существует.

7. Условный оператор (if-else)

Go: Проверяемое условие пишется без круглых скобок `if x > 0 {}`.

Си: Условие внутри `if` обязательно должно быть заключено в круглые скобки `()`. Если ветка состоит из одного оператора, фигурные скобки `{}` можно опустить.

Python: После условия ставится двоеточие `:`, тело условия выделяется отступом.

8. Множественный выбор (switch)

Go: После выполнения совпавшего `case` программа автоматически выходит из `switch`.

Си: Константы в `case` работают как метки. Если в конце ветки явно не написать оператор `break;`, программа "провалится" в выполнение всех последующих `case`.

Python: Аналог (конструкция `match / case`) появился только в версии 3.10.

9. Циклы

Go: Единственный и универсальный цикл `for`, заменяющий собой все остальные конструкции.

Си: Существует три различных вида циклов: параметрический `for (иниц; условие; шаг)`, цикл с предусловием `while (условие)` и цикл с постусловием `do { ... } while (условие);`.

Python: Используются циклы `for ... in` для итерации по коллекциям и цикл `while`.

10. Функции и возврат значений

Go: Определяются словом `func`. Могут возвращать множество значений одновременно.

Си: Ключевого слова для функций нет. Тип возвращаемого значения пишется до имени функции. Функция может вернуть только одно значение. Если ничего не возвращает — используется тип `void`.

Python: Определяются словом `def`. Способны возвращать множество значений (через кортежи).

11. Указатели и передача параметров

Go: Параметры передаются по значению. Указатели (`` и `&`) используются для изменения оригинальных данных.

Си: Все аргументы передаются исключительно по значению. Для изменения переменной внутри функции программист обязан вручную передать её физический адрес в памяти (с помощью оператора `&`), а функция должна принимать этот адрес в параметр-указатель.

Python: Неявная передача по ссылке (функция оперирует идентификаторами объектов).

12. Массивы и срезы

Go: Широко применяются динамические срезы (slices) со встроенной проверкой границ и хранением длины.

Си: Массив — это блок памяти жестко фиксированного размера, задаваемого при компиляции. Язык не контролирует выход индекса за границы массива.

Python: Роль динамических массивов выполняют встроенные списки `list`.

13. Адресная арифметика

Go: Математические вычисления с указателями запрещены ради безопасности.

Си: Имя массива является указателем на его первый элемент. В Си разрешено выполнять арифметические операции над указателями (например, складывать указатель с целым числом `ptr + i` или выполнять инкремент `ptr++`) для перемещения по ячейкам памяти.

Python: Работа с адресами памяти и адресная арифметика абстрагированы интерпретатором.

14. Строки и символы

Go: Встроенный и безопасный тип `string`.

Си: Встроенного типа данных для строк не существует. Строка — это обычный массив символов типа `char`, который по правилу языка должен оканчиваться специальным нуль-терминатором (символом `\0`).

Python: Безопасный встроенный тип `str`.

15. Структуры данных (ООП против Процедурности)

Go: Структуры (`struct`) используются для ООП: к ним можно привязывать методы через receiver.

Си: Создание пользовательских типов данных осуществляется через конструкцию `struct`. Структура объединяет переменные, но внутри неё нельзя определять методы (функции). Си — чисто процедурный язык.

Python: Полноценное объектно-ориентированное программирование с классами (`class`) и наследованием.

16. Управление динамической памятью

Go: Встроенный сборщик мусора (Garbage Collector) автоматически очищает неиспользуемую память.

Си: Механизма автоматической сборки мусора нет. Программист обязан вручную выделять динамическую память системной функцией `malloc()` и обязательно освобождать её функцией `free()`. Забытый `free()` приводит к утечкам памяти.

Python: Память автоматически управляется сборщиком мусора (через подсчет ссылок и алгоритм mark-and-sweep в CPython).

17. (Дополнительная тема) Объединения (union) и указатели на функции

Go: Имитация полиморфизма достигается за счет интерфейсов (`interface`).

Си: Для экономии памяти используется спецтип `union`, где несколько разнотипных переменных накладываются на один и тот же физический участок оперативной памяти. В качестве архитектурного приема (например, для callback-вызовов и имитации ООП) активно используются указатели на функции.

Python: Функции являются объектами первого класса. Разные типы данных в одном месте поддерживаются за счет динамической "утиной" типизации.

Темы докладов ниже пронумерованы цифрами (для групп где 25 и 27 человек):

Блок 1: Базовый синтаксис и типы данных

Точка входа и структура программы: main() в Си против package main в Go и скриптового выполнения в Python. Директивы #include против import.

Лексика и форматирование кода: «Проклятие» фигурных скобок {} и точек с запятой ; в Си/Go против отступов в Python.

Примитивные типы данных и их размеры: Типы в Си (int, char, float) против платформонезависимых типов Go и объектов в Python. Отсутствие встроенного логического типа bool в классическом Си.

Объявление, инициализация и типизация: Строгая типизация Си против динамической в Python. Почему в Си нет оператора := из Go и что такое «мусор» в неинициализированной памяти.

Константы и литералы: Символические константы через #define в Си против типизированных констант const в Go и отсутствия констант в Python.

Преобразование и приведение типов (Casting): Неявные приведения компилятора Си (ловушки типов) против строгого явного приведения в Go и динамической типизации Python.

Блок 2: Операторы и Управление потоком

7. Арифметические операторы и инкремент: Математика языков. Особенности встраиваемого инкремента/декремента (++, --) в Си против их реализации в Go как отдельной инструкции и полного отсутствия в Python.

8. Побитовые операции и маски: Прямой доступ к железу (&, |, ^, <<, >>). Применение битовых масок в Си по сравнению с Go и Python.

9. Логические операторы и проверка истинности: Как Си оценивает условия (0 = ложь, всё остальное = истина) в сравнении со строгим типом bool в Go/Python. «Ленивое» (короткое) вычисление логических выражений.

10. Условное ветвление (if-else и тернарный оператор): Обязательность круглых скобок в Си против их отсутствия в Go. Тернарный оператор ?: в Си и его аналоги в других языках.

11. Множественный выбор (switch-case): Опасность «проваливания» (fall-through) без оператора break в Си против безопасного switch в Go и конструкции match в Python.

12. Циклы с предусловием и счетчиком: Различия классического for(;;) и while() в Си против единого универсального for в Go и итератора for..in в Python.

13. Циклы с постусловием и операторы перехода: do-while, break, continue. Особый акцент на оператор безусловного перехода goto в Си: зачем он нужен и почему изгнан из Python.

Блок 3: Память, Указатели и Массивы

14. Указатели — фундамент Си: Понятие физического адреса. Операторы взятия адреса & и разыменования *. Скрытые указатели в Python (идентификаторы объектов).

15. Адресная арифметика: Перемещение по ячейкам оперативной памяти (операции ptr++, ptr+i). Почему это разрешено в Си, но строго запрещено компилятором Go для безопасности.

16. Статические массивы: Выделение непрерывного блока памяти в Си, отсутствие контроля выхода за границы массива компилятором против безопасных коллекций Go и Python. Имя массива как константный указатель.

17. Динамические коллекции (Срезы vs Списки): Почему в Си нет встроенных динамических списков. Как слайсы (slices) в Go и списки (list) в Python физически реализованы через Си-структуры на уровне их движков.

18. Строки (Иллюзия текста): Отсутствие встроенного типа string в Си. Строка как массив char и правило «нуль-терминатора» \0. Безопасные строки со счетчиком длины в Go и Python.

19. Многоуровневые указатели: Указатели на указатели (**ptr) и массивы указателей в Си. Их использование для хранения таблиц и массивов строк под капотом высокоуровневых языков.

Блок 4: Функции и Процедурное программирование

20. Определение функций и возврат значений: Синтаксис без слова func/def. Строгий возврат только одного значения в Си и тип void, в отличие от множественного возврата в Go и Python.

21. Передача аргументов по значению и «по ссылке»: Как Си эмулирует передачу по ссылке через явную передачу адресов (&x). Почему то, что в Python/Java называют «передачей объекта по ссылке», на уровне Си является копированием указателя.

22. Указатели на функции: Передача функции как аргумента (callback). Как Си компенсирует отсутствие функций как «объектов первого класса» (в отличие от Python и Go).

23. Классы памяти и область видимости: Глобальные и локальные переменные. Ключевые слова extern (для связи файлов), static (скрытие в файле) и register (регистры процессора) в Си.

Блок 5: Пользовательские типы и Управление ресурсами

24. Структуры (struct) и синонимы типов (typedef): Процедурный подход Си. Компоновка разнородных данных в памяти. Почему в структуре Си нельзя писать методы (в отличие от receiver в Go и классов в Python).

25. Объединения (union) и битовые поля: Экзотические типы Си для жесткой экономии ОЗУ. Наложение разных переменных на один физический адрес памяти. Отсутствие прямых аналогов в Go/Python.

26. Ручное управление динамической памятью: Системные функции Си (malloc, calloc, free). Ответственность программиста за утечки памяти (Memory Leaks).

27. Автоматическое управление памятью под капотом: Жизнь без free. Как именно на языке Си реализованы Garbage Collector в Go (mark-and-sweep) и механизм подсчета ссылок (reference counting) в ядре CPython.

ДОКЛАДЫ 2, 3, 4, 5

ДЛЯ ГРУППЫ ГДЕ 25 человек (100 докладов)

Блок I. Обход коллекций, массивы, индексы, указатели

1. Обход массива по индексу: C array, Go array, Python list

Одна задача: пройти по числам и посчитать сумму.
C: for (int i = 0; i < n; i++).
Go: for i := 0; i < len(a); i++.
Python: for i in range(len(a)).
Дополнительно: показать, как Python list внутри является массивом указателей на объекты.

2. Обход массива через указатель в C и его аналоги в Go/Python

C: int *p = arr; p < arr+n; p++.
Go: прямой pointer arithmetic запрещен, используется индекс или range.
Python: прямых указателей нет, обход идет через iterator protocol.
На C реализовать “итератор” как структура {current, end}.

3. Go `range` по массиву и slice: что копируется, что нет

Одинаковая задача: изменить элементы массива в цикле.
Показать ошибку Go: изменение переменной v из for _, v := range не меняет массив.
C: изменение через индекс или указатель.
Python: изменение списка через индекс.
На C реализовать псевдо-range, возвращающий индекс и копию значения.

4. Python iterator protocol против Go `range` и C-итератора

Задача: пройти коллекцию своим объектом-итератором.
Python: __iter__, __next__.
Go: имитация через функцию Next().
C: структура Iterator + функция next.
На C показать, как Python-итератор концептуально хранит состояние.

5. Выход за границы коллекции

C: undefined behavior при arr[100].
Go: panic: index out of range.
Python: IndexError.
Показать одинаковый код и три разных последствия.
На C реализовать безопасный доступ array_get(arr, len, index, &out).

6. Передача массива в функцию

C: массив “превращается” в указатель.
Go: array передается по значению, slice — как дескриптор.
Python: передается ссылка на объект list.
На C показать три модели: указатель, копия структуры, указатель на динамический объект.

7. Многомерные массивы

C: int a[rows][cols].
Go: [rows][cols]int и [][]int.
Python: список списков.
На C показать layout в памяти: непрерывный блок против массива указателей.

8. Плоский массив против массива массивов

Одна задача: матрица 3×3.
C: int data[9] и индекс row * cols + col.
Go: slice длиной rows*cols.
Python: list длиной rows*cols.
Показать, почему плоская память быстрее и проще для cache locality.

9. Итерация с фильтрацией

Задача: выбрать только четные числа.
C: ручной цикл и запись в выходной массив.
Go: append в slice.
Python: list comprehension.
На C реализовать аналог list comprehension как функцию filter.

Блок II. Динамические массивы, slice, list

10. Go slice как структура `{ptr, len, cap}`

C-кодом реализовать структуру:

typedef struct {
    int *data;
    size_t len;
    size_t cap;
} IntSlice;
Потом показать аналог в Go и Python.

Цель: понять, что slice — не сам массив, а дескриптор массива.

11. Python list как динамический массив указателей

Показать, что list хранит не сами объекты, а ссылки на них.
C-модель:

typedef struct {
    PyObject **items;
    size_t len;
    size_t allocated;
} PyListLike;

Сравнить с Go slice и C dynamic array.

12. `append` в Go, `append` в C, `append` в Python

Одинаковая операция: добавить элемент.
C: проверка capacity + realloc.
Go: append.
Python: list.append.
На C написать полную функцию роста массива.

13. Capacity growth: почему массив растет не на 1 элемент

Показать стратегию увеличения capacity.
C: вручную cap *= 2.
Go: runtime сам выбирает рост.
Python: CPython использует overallocation.
На C показать, как меняется число аллокаций.

14. Slice как view на массив

Go: два slice смотрят на один underlying array.
C: два указателя на один буфер.
Python: обычный срез list создает новый list, а не view.
Показать ошибку aliasing в Go.

15. Копирование slice/list/array

C: memcpy.
Go: copy(dst, src).
Python: a[:], list(a), copy.copy.
На C различить shallow copy и deep copy.

16. Удаление элемента из динамического массива

C: memmove.
Go: append(s[:i], s[i+1:]...).
Python: del a[i].
На C показать, сколько элементов реально сдвигается.

17. Вставка элемента в середину массива

C: capacity check + memmove.
Go: создание места через append/copy.
Python: list.insert.
Показать стоимость O(n).

18. Стек поверх массива

Реализовать stack: push, pop, peek.
C: свой dynamic array.
Go: slice.
Python: list.
На C показать, что Python list и Go slice часто используются как стек.

Блок III. Строки, bytes, Unicode

19. C string как `char*` + `\0`

Задача: посчитать длину строки.
C: идти до нулевого байта.
Go: len(s) считает байты.
Python: len(s) считает Unicode code points.
На C реализовать strlen.

20. Go string как immutable byte sequence

Показать строку с кириллицей.
Go: len(s) в байтах, for range по rune.
C: UTF-8 как массив байтов.
Python: Unicode-строка.
На C написать обход UTF-8 по байтам и объяснить сложность rune.

21. Python `str` и `bytes`

Одна задача: закодировать строку в UTF-8 и обратно.
C: char* как байты без знания Unicode.
Go: string ↔ []byte.
Python: .encode() и .decode().
На C показать, что кодировка — это соглашение, а не магия типа char*.

22. Конкатенация строк

C: выделить буфер и вызвать strcpy/strcat или snprintf.
Go: +, strings.Builder.
Python: +, ''.join.
На C показать цену многократной конкатенации.

23. Изменяемые и неизменяемые строки

C: массив char buf[] изменяем, литерал менять нельзя.
Go string immutable.
Python str immutable.
На C показать, почему изменение string literal опасно.

24. Срез строки

C: указатель + длина.
Go: s[i:j] как view на байты.
Python: s[i:j] создает новую строку.
На C реализовать StringView {char *ptr; size_t len;}.

25. Поиск подстроки

C: strstr или ручной алгоритм.
Go: strings.Contains, strings.Index.
Python: in, .find.
На C реализовать простой поиск и объяснить сложность.

26. Разбиение строки

C: strtok и его проблемы.
Go: strings.Split.
Python: str.split.
На C написать безопасный split, возвращающий динамический массив строк.

27. Строка как объект: CPython `PyUnicodeObject`

Показать, что Python str — не char*, а объект с метаданными.
Сравнить с C string и Go string header.
На C нарисовать упрощенную структуру Python-строки.

Блок IV. Структуры, объекты, layout памяти

28. C `struct` как основа всех сложных данных

Одна сущность User: id, name, active.
C: struct User.
Go: type User struct.
Python: class User или dataclass.
Показать layout в памяти.

29. Go struct против C struct

Поля, порядок полей, доступ через ., копирование по значению.
На C показать, почему Go struct легко моделируется C-структурой.

30. Python object как структура с заголовком

Показать, что Python-объект имеет не только поля пользователя, но и служебный заголовок.
C-модель:

typedef struct {
    long refcnt;
    TypeObject *type;
    Dict *attrs;
} PyObjectLike;
Сравнить с Go/C struct.

31. Padding и alignment в C и Go

Показать две структуры с одинаковыми полями, но разным порядком.
C: sizeof.
Go: unsafe.Sizeof.
Python: накладные расходы объекта.
На C объяснить выравнивание.

32. Указатель на структуру

C: User *u.
Go: *User.
Python: имя всегда ссылается на объект.
Показать изменение поля внутри функции.

33. Копирование структуры

C: u2 = u1.
Go: u2 := u1.
Python: u2 = u1 не копирует объект.
На C показать shallow copy и проблему внутренних указателей.

34. Struct с динамическими полями

C: структура содержит char *name.
Go: структура содержит string или slice.
Python: объект содержит ссылку на строку.
На C разобрать владение вложенной памятью.

35. Массив структур против массивов указателей

C: User users[100] против User* users[100].
Go: []User против []*User.
Python: list всегда хранит ссылки.
Показать cache locality и стоимость разыменования.

36. Объектная идентичность

C: адрес структуры.
Go: адрес значения или pointer identity.
Python: id(obj) и is.
На C показать, почему два одинаковых объекта могут иметь разные адреса.

Блок V. Указатели, ссылки, стек, куча

37. C pointer arithmetic и почему в Go/Python этого нет

C: p++, *(p+i).
Go: pointer есть, arithmetic запрещена.
Python: прямых указателей нет.
На C показать пользу и опасность pointer arithmetic.

38. Передача по значению и передача по адресу

C: func(x) против func(&x).
Go: value receiver и pointer receiver.
Python: object reference.
Показать одинаковую функцию increment.

39. Stack frame функции

C: параметры, локальные переменные, return address.
Go: стек goroutine, растущий стек.
Python: frame object.
На C нарисовать стек вызовов.

40. Heap allocation

C: malloc/free.
Go: new, escape analysis, heap.
Python: все объекты управляются рантаймом.
Показать создание объекта User.

41. Dangling pointer в C и почему Go/Python безопаснее

C: вернуть адрес локальной переменной.
Go: compiler escape analysis спасает ситуацию.
Python: объект живет, пока есть ссылки.
На C показать ошибку времени жизни.

42. Memory leak

C: забыли free.
Go: объект удерживается ссылкой, GC не освобождает.
Python: глобальная ссылка или цикл.
Показать разные виды утечек.

43. Ownership как дисциплина проектирования

C: кто выделил — тот освобождает.
Go: владение через соглашения API.
Python: владение скрыто, но aliasing остается.
На C показать create/destroy API.

44. Shallow copy и deep copy объектов

C: копирование структуры с указателем.
Go: struct copy со slice/map внутри.
Python: copy.copy и copy.deepcopy.
На C написать deep copy для User.

45. Reference counting как C-механизм

Написать простую структуру:




typedef struct {
    int refcnt;
    void *data;
} RcObject;

Показать аналогию с CPython Py_INCREF/Py_DECREF.

Блок VI. Функции, callback, closure

46. Функция как значение

C: function pointer.
Go: function value.
Python: function object.
Задача: передать функцию compare или predicate.

47. Callback с пользовательским контекстом

C: void (*fn)(void*) + void *ctx.
Go: closure захватывает переменные.
Python: closure или callable object.
На C показать, как контекст заменяет замыкание.

48. Замыкание-счетчик

Python: функция внутри функции.
Go: anonymous function с captured variable.
C: структура {state, function_pointer}.
Показать одинаковый counter().

49. Variadic functions

C: printf, stdarg.h.
Go: func f(xs ...int).
Python: *args, **kwargs.
На C объяснить опасность variadic без type safety.

50. Multiple return values

Go: value, err.
Python: tuple unpacking.
C: return code + out-parameter.
Показать функцию parse_int.

51. Method as function

C: user_greet(&user).
Go: user.Greet().
Python: user.greet().
Показать, что метод — это функция с неявным или явным объектом.

52. Bound method в Python

Python: obj.method уже содержит self.
Go: method value тоже может захватить receiver.
C: вручную хранить {object_pointer, function_pointer}.
На C реализовать bound method.

53. Higher-order functions: map/filter/reduce

C: function pointer + loop.
Go: generic function или function parameter.
Python: list comprehension, map, filter.
На C написать универсальный filter_int.

54. Function object как структура

Python-функция — объект.
Go-функция — значение с возможным environment.
C: function pointer + environment.
Показать C-модель function object.

Блок VII. Python ООП и его реализация через Go/C

55. Python class как шаблон объектов

Python: class User.
Go: struct User + методы.
C: struct User + функции.
Показать один и тот же User во всех трех языках.

56. Python `init` как C/Go-конструктор

Python: __init__.
Go: NewUser.
C: user_init или user_new.
Показать выделение и инициализацию объекта.

57. Python instance attributes

Python: self.name = name.
Go: поле структуры.
C: поле структуры.
На C показать словарь атрибутов как динамический вариант Python-объекта.

58. Python class attributes

Python: атрибут класса общий для всех экземпляров.
Go: package-level variable или static-like значение.
C: global/static variable рядом с type descriptor.
На C смоделировать class object.

59. Python method lookup

Python ищет метод в объекте, классе, базовых классах.
Go метод определяется статически по типу.
C: ручная таблица методов.
Показать C-реализацию lookup по имени метода.

60. Python `self` против Go receiver против C pointer

Одна задача: метод меняет поле объекта.
Python: self.x.
Go: pointer receiver.
C: User *self.
Показать полное соответствие строк.

61. Python inheritance

Python: class Admin(User).
Go: struct embedding.
C: первая часть структуры — базовая структура.
Показать layout “наследования” в C.

62. Python `super()` через C-таблицу базовых классов

Python: super().method().
Go: явный вызов embedded field.
C: указатель на base type descriptor.
Показать псевдо-MRO.

63. Python method overriding

Python: дочерний класс переопределяет метод.
Go: embedded type + метод внешнего типа.
C: заменить function pointer в vtable.
Показать одинаковый пример describe().

64. Python duck typing

Python: объект подходит, если имеет нужный метод.
Go: interface satisfied implicitly.
C: структура с vtable нужной формы.
Показать пример Printable.

65. Python special methods

Python: __str__, __len__, __eq__.
Go: String() для fmt.Stringer, Equal как метод.
C: slots в type object.
На C показать таблицу специальных операций.

66. Python property

Python: @property.
Go: getter/setter методы.
C: function pointers get_name, set_name.
Показать C-модель descriptor.

67. Python descriptor protocol

Python: __get__, __set__, __delete__.
Go: прямого аналога нет, можно сделать методами.
C: структура descriptor с function pointers.
Показать, как descriptor участвует в доступе к атрибуту.

68. Python metaclass как объект, создающий классы

Python: class тоже объект.
Go: типы статичны, метаклассов нет.
C: type descriptor создает instance.
Показать мини-систему типов на C.

69. Python `isinstance` и `type`

Python: проверка runtime type.
Go: type assertion/type switch.
C: поле type внутри объекта.
На C реализовать is_instance(obj, type).

Блок VIII. Go ООП и его реализация через C/Python

70. Go struct + methods как ООП без классов

Go: type User struct + func (u User) Name().
Python: class.
C: struct + функции.
Показать, что Go-метод — синтаксический сахар над функцией с receiver.

71. Value receiver против pointer receiver

Go: копия объекта или указатель.
C: передать struct по значению или User*.
Python: всегда ссылка на объект.
Показать ошибку изменения копии.

72. Go interface как контракт поведения

Go: интерфейс Reader.
Python: duck typing.
C: vtable.
На C реализовать interface object.

73. Go interface внутри: type + value

C-модель:




typedef struct {
    TypeInfo *type;
    void *data;
} Interface;

Сравнить с Python object header и C void*.

74. Nil interface problem в Go

Показать var err error = (*MyError)(nil).
C: interface struct содержит type, но data nil.
Python: None как отдельный объект.
Разобрать, почему err != nil.

75. Type assertion

Go: v, ok := x.(T).
Python: isinstance.
C: проверить type_id и привести void*.
Показать безопасный downcast.

76. Type switch

Go: switch v := x.(type).
Python: match/isinstance.
C: switch(obj->type_id).
Показать обработку разных типов сообщений.

77. Go embedding

Go: встроенная структура.
Python: композиция или наследование.
C: вложенная структура первым полем.
Показать promoted methods как явные wrapper-функции.

78. Go interface dispatch против Python dynamic dispatch

Go: вызов через interface table.
Python: lookup метода по имени.
C: вызов function pointer из vtable.
Сравнить стоимость и гибкость.

79. Go package-level encapsulation

Go: экспорт через заглавную букву.
Python: _private как соглашение.
C: static functions в .c файле.
Показать один модуль с публичным API.

80. Go constructor pattern

Go: NewUser.
Python: __init__.
C: user_new/user_free.
Показать, как скрыть внутреннюю структуру за API.

81. Go generics как типизированный аналог C macro и Python dynamic code

Go: Stack[T].
Python: generic type hints, но runtime динамический.
C: macro или void*.
На C реализовать generic stack двумя способами.

Блок IX. Dict, map, hash table, set

82. C hash table с нуля

Реализовать put, get, delete.
Go: map[string]int.
Python: dict.
Показать, что map/dict — не магия, а hash table.

83. Hash function

C: написать простую hash-функцию для строки.
Go/Python: показать, что ключ должен быть hashable/comparable.
Разобрать collision.

84. Collision resolution

C: chaining или open addressing.
Go: buckets.
Python dict: open addressing-подобная схема.
Показать, как несколько ключей попадают в одну область.

85. Resize hash table

C: при большом load factor пересоздать таблицу.
Go/Python: resize скрыт внутри runtime.
Показать стоимость rehash.

86. Python dict как объектная основа атрибутов

Python object attributes часто хранятся в dict-подобной структуре.
Go struct fields фиксированы.
C struct fields фиксированы.
Показать динамическое добавление obj.new_field = 123.

87. Go map nil и empty map

Go: nil map нельзя записывать.
Python: {} всегда объект dict.
C: HashMap *m = NULL против инициализированной таблицы.
Показать ошибки и проверки.

88. Set

C: hash table без значений.
Go: map[T]bool или map[T]struct{}.
Python: set.
Реализовать уникализацию списка.

89. Ordered behavior

Python dict сохраняет порядок вставки.
Go map порядок обхода не гарантирует.
C hash table может хранить или не хранить порядок.
Показать один и тот же обход.

90. Object registry

Создать реестр объектов по имени.
C: hash table name -> object*.
Go: map[string]Object.
Python: dict[str, object].
Использовать как основу для динамического ООП.

Блок X. Ресурсы, файлы, буферы, ошибки

91. Файл как ресурс

C: FILE*.
Go: *os.File.
Python: file object.
Показать открытие, чтение, закрытие.

92. Автоматическое освобождение ресурса

C: goto cleanup.
Go: defer f.Close().
Python: with open(...).
На C реализовать дисциплинированный cleanup.

93. Буферизированное чтение

C: fgets в фиксированный буфер.
Go: bufio.Scanner.
Python: iterator по файлу.
Показать, где хранится буфер.

94. Buffer overflow

C: переполнение массива.
Go: bounds check.
Python: object-level safety.
Показать безопасный C API с передачей размера буфера.

95. Ошибка как значение

C: код возврата.
Go: error.
Python: exception.
Одна задача: открыть несуществующий файл.

96. `errno`, wrapped error, traceback

C: errno.
Go: fmt.Errorf("...: %w", err).
Python: traceback и chaining exceptions.
Сравнить диагностику.

97. Null, nil, None

C: NULL.
Go: nil.
Python: None.
Показать проверку отсутствующего значения в API.

98. Segmentation fault, panic, exception

C: разыменование NULL.
Go: nil pointer dereference panic.
Python: AttributeError.
Показать одинаковую логическую ошибку.

99. `panic/recover`, Python exception, C `setjmp/longjmp`

Сравнить аварийное управление потоком.
На C показать setjmp/longjmp, но объяснить, почему это не обычная обработка ошибок.

Блок XI. CPython на C и C-модель Go-механизмов

100. Мини-`PyObject` на C

Реализовать объект с refcnt, type, data.
Python: показать обычный объект.
Go: сравнить с interface type/value.
Цель: понять основу CPython object model.

ДЛЯ ГРУППЫ ГДЕ 17 человек (68 тем)

Блок I. Основа языка: запуск, синтаксис, типы, выполнение

1. “Hello, World”: минимальная программа в Go, C и Python

Построчно сравнить main, точку входа, импорт библиотек, вывод в консоль.
На C показать, как процесс получает argv, как вызывается main, что делает стандартная библиотека перед запуском программы.
Для Python — как CPython читает файл, компилирует его в байткод и запускает интерпретатор.

2. Компиляция против интерпретации: `gcc`, `go build`, `python script.py`

Показать путь исходника: текст → токены → AST → машинный код / байткод.
Сравнить C как компилируемый язык, Go как компилируемый язык с рантаймом, Python как интерпретируемый через VM.
На C разобрать, что такое объектный файл, линковка, символы и загрузка программы.

3. Лексика языка: пробелы, отступы, точки с запятой, комментарии

Построчно показать одинаковый фрагмент с комментариями, блоками и выражениями.
Сравнить {} в C/Go и отступы в Python.
На C показать, как лексер мог бы разбивать текст программы на токены.

4. Переменные: объявление, присваивание, область видимости

Сравнить int x = 10;, var x int = 10, x = 10.
Объяснить статическую типизацию C/Go и динамическую привязку имени в Python.
На C показать таблицу символов и ячейки памяти для переменных.

5. Константы и литералы: `const`, `#define`, `iota`, числовые и строковые значения

Сравнить константы в C, Go и Python.
Показать разницу между препроцессорной подстановкой C, типизированными константами Go и соглашением UPPER_CASE в Python.
На C объяснить, что #define не является переменной.

6. Примитивные типы: целые, вещественные, bool, char, rune, complex

Сравнить int, float, double, bool, char, rune, str, bytes.
Показать размеры типов, переполнение, знаковость, Unicode.
На C разобрать представление чисел в памяти: байты, порядок байтов, IEEE 754.

7. Операторы и выражения: арифметика, сравнение, логика, приоритеты

Построчно сравнить выражения в трех языках.
Показать отличия /, %, &&, and, ||, or, !, not.
На C разобрать порядок вычисления, побочные эффекты и опасные выражения вроде i++ + ++i.

8. Условия: `if`, `else`, `switch`, `match`-подобные конструкции

Сравнить if в C, Go и Python.
Показать switch в C и Go, а также match в Python как более современную конструкцию сопоставления.
На C объяснить, как switch может компилироваться в цепочку сравнений или jump table.

9. Циклы: `for`, `while`, `range`, бесконечные циклы

Сравнить for в C, универсальный for в Go и for/while в Python.
Показать обход массива, строки, словаря/map.
На C объяснить, как цикл превращается в условные переходы и метки на уровне машинного кода.

Блок II. Данные и память

10. Массивы: фиксированная длина в C и Go, списки в Python

Сравнить int a[3], [3]int, list.
Показать индексацию, границы, длину, хранение в памяти.
На C объяснить, почему массив — это непрерывный блок памяти.

11. Slice в Go, указатель + длина в C, list в Python

Построчно реализовать срез массива: взять часть данных, изменить элемент, передать в функцию.
На C показать структуру вида {ptr, len, cap} как модель Go slice.
Для Python показать, что срез списка создает новый список, а не просто view.

12. Строки: `char*`, `string`, `str`, UTF-8 и Unicode

Сравнить строковые литералы, длину строки и доступ к символам.
На C объяснить '\0', буфер, strlen, опасность выхода за границы.
Для Go показать byte и rune; для Python — Unicode-строку и bytes.

13. Структуры данных: `struct` в C, `struct` в Go, object/class в Python

Показать одну сущность, например User, во всех трех языках.
Сравнить поля, методы, инициализацию, доступ к данным.
На C объяснить layout структуры: смещения полей, padding, alignment.

14. Указатели, ссылки и идентичность объекта

Сравнить int* p, &x, *p, указатели в Go и объектные ссылки в Python.
Показать, что передается в функцию: значение, адрес, ссылка на объект.
На C объяснить адресное пространство, стек, куча, dangling pointer.

15. Стек и куча: где живут переменные

Сравнить локальные переменные, динамическое выделение, объекты Python.
В Go разобрать escape analysis: когда значение уходит в heap.
На C показать malloc, free, стековый кадр функции и утечки памяти.

16. Время жизни объекта: ручное управление, GC, reference counting

Сравнить malloc/free в C, garbage collector в Go, reference counting + cyclic GC в CPython.
Показать пример создания и освобождения объекта.
На C написать минимальную модель счетчика ссылок как у CPython.

17. Копирование и aliasing: когда меняется оригинал

Сравнить присваивание массива, slice, struct, list, dict.
Показать, где копируется значение, а где копируется ссылка/дескриптор.
На C объяснить shallow copy и deep copy через memcpy и ручное копирование.

18. Выравнивание, padding и размер объекта

Сравнить размер структуры в C и Go, а также накладные расходы Python-объекта.
Показать, почему порядок полей влияет на размер.
На C объяснить sizeof, alignment, cache line и layout объекта.

Блок III. Функции, вызовы, ошибки, абстракции

19. Функции: сигнатура, параметры, возвращаемое значение

Сравнить int add(int a, int b), func add(a int, b int) int, def add(a, b):.
Показать типы аргументов и возвращаемых значений.
На C объяснить call stack, передачу параметров и возвращение результата.

20. Несколько возвращаемых значений: Go, Python tuple, C через out-параметры

Сравнить функцию деления, возвращающую результат и ошибку.
Go: (value, err), Python: (value, error) или exception, C: код ошибки + указатель на результат.
На C показать паттерн int func(..., Result *out).

21. Variadic-функции: `printf`, `...`, `*args`

Сравнить переменное число аргументов в C, Go и Python.
Показать форматированный вывод.
На C объяснить stdarg.h, va_list, риск несоответствия формата и аргумента.

22. Функции как значения: callback, function pointer, closure

Сравнить callback в C, функцию-переменную в Go и функцию как объект в Python.
Показать сортировку с пользовательским компаратором.
На C объяснить указатель на функцию и передачу контекста через void*.

23. Замыкания: captured variables в Go и Python, ручная модель в C

Показать функцию, возвращающую счетчик.
Go и Python умеют замыкания напрямую.
На C реализовать замыкание как структура {state, function_pointer}.

24. Методы: receiver в Go, `self` в Python, функции над struct в C

Сравнить метод User.Greet().
В C показать функцию user_greet(User *u).
В Go — value receiver и pointer receiver; в Python — self.

25. Интерфейсы и протоколы: Go interface, Python duck typing, C vtable

Сравнить объект, который “умеет печатать себя” или “умеет читать данные”.
На C реализовать интерфейс через таблицу указателей на функции.
Показать, как это похоже на Go interface и Python object protocol.

26. Обобщенное программирование: Go generics, C macros/void*, Python typing

Сравнить функцию max, стек или список для разных типов.
C: макросы, void*, _Generic; Go: type parameters; Python: динамика + type hints.
На C показать цену универсальности: касты, потеря типобезопасности.

27. Ошибки: return codes, `error`, exceptions

Сравнить открытие файла, парсинг числа, сетевой запрос.
C: errno и коды возврата; Go: if err != nil; Python: try/except.
На C объяснить, почему исключения не являются частью стандартного C.

Блок IV. Модульность, объектность, типовые системы

28. Модули и пакеты: `.h/.c`, Go packages, Python modules

Сравнить разбиение программы на несколько файлов.
C: header + implementation; Go: package; Python: module/package.
На C объяснить declaration vs definition, include guards и линковку.

29. Инкапсуляция: `static`, заглавные имена Go, `_private` в Python

Показать публичные и приватные функции/поля.
C: static на уровне файла; Go: экспорт через заглавную букву; Python: соглашения _name и name mangling.
На C объяснить видимость символов при линковке.

30. Композиция вместо наследования

Сравнить вложенные структуры в C, embedding в Go и композицию классов в Python.
Показать модель Logger, Service, Repository.
На C реализовать композицию как вложенную структуру и указатели на зависимости.

31. Наследование и его аналоги

Python: классы и наследование.
Go: embedding и интерфейсы вместо классического inheritance.
C: ручная эмуляция через struct embedding и vtable.

32. Полиморфизм: vtable, interface dispatch, dynamic dispatch

Показать несколько типов, реализующих один контракт: Shape.Area().
C: таблица функций; Go: interface; Python: метод с одинаковым именем.
На C объяснить, как динамический вызов превращается в вызов функции по указателю.

33. Конструкторы и деструкторы

Сравнить new_user, NewUser, __init__.
C: ручная инициализация и освобождение; Go: фабричная функция; Python: __init__ и __del__.
На C показать безопасный шаблон init/destroy.

34. Перегрузка операторов и специальные методы

Python: __add__, __len__, __iter__.
C: операторов для пользовательских типов нет, используются функции.
Go: перегрузки операторов для пользовательских типов нет, но есть методы и интерфейсы.

35. Итераторы: `for`, `range`, iterator protocol

Сравнить обход коллекции.
Python: __iter__, __next__; Go: range; C: индекс, указатель или iterator-struct.
На C реализовать простой итератор с функцией next.

36. Рефлексия и интроспекция

Go: reflect, Python: dir, getattr, type, inspect, C: почти нет встроенной рефлексии.
Показать сериализацию структуры в JSON.
На C объяснить, почему без метаданных рантайма рефлексия невозможна.

Блок V. Управление ресурсами и безопасность

37. Файлы: открыть, прочитать, закрыть

Сравнить fopen/fread/fclose, os.Open/defer Close, with open(...).
Показать одинаковое чтение файла построчно.
На C разобрать буферизацию, дескриптор файла и риск забыть fclose.

38. `defer`, `goto cleanup`, context manager

Сравнить освобождение ресурсов при нескольких ошибках.
C: goto cleanup; Go: defer; Python: with.
На C показать, как context manager можно смоделировать вручную.

39. Буферы и безопасность памяти

Сравнить чтение строки в буфер в C, bufio.Scanner в Go, readline в Python.
Показать переполнение буфера в C и безопасные аналоги.
На C объяснить stack buffer overflow.

40. Undefined Behavior в C и отсутствие прямого аналога в Go/Python

Показать выход за границу массива, use-after-free, signed overflow.
Сравнить, как Go и Python обычно дают panic/exception.
На C объяснить, почему UB позволяет компилятору делать агрессивные оптимизации.

41. Integer overflow: C, Go, Python

C: зависит от типа и знаковости; Go: фиксированное переполнение для unsigned и поведение для целых типов; Python: большие целые без фиксированного лимита размера.
Показать max_int + 1.
На C разобрать представление two’s complement.

42. Null, nil, None

Сравнить NULL, nil, None.
Показать ошибку обращения к отсутствующему объекту.
На C объяснить нулевой указатель и segmentation fault.

43. Исключения, panic/recover и аварийное завершение

Python: raise, try/except/finally; Go: panic/recover, но обычные ошибки через error; C: setjmp/longjmp как низкоуровневая имитация.
На C показать, почему longjmp опасен для ресурсов.

44. Контракты и проверки: assert, тестовые инварианты, defensive programming

Сравнить assert в C, Go-тесты, Python assert.
Показать проверку предусловий функции.
На C объяснить NDEBUG и отключение assert в release-сборке.

45. Безопасные API: как проектировать функции, чтобы ими трудно было ошибиться

Сравнить API для чтения данных, выделения памяти, парсинга.
C: явные размеры буферов; Go: возврат (n, err); Python: исключения и высокоуровневые объекты.
На C показать плохой и хороший дизайн функции.

Блок VI. Конкурентность и параллелизм

46. Потоки: pthreads в C, goroutines в Go, threading в Python

Показать запуск параллельной задачи.
Сравнить стоимость потоков, goroutine и Python thread.
На C объяснить системный поток и стек потока.

47. Планировщик Go: goroutine, M:N scheduling и C-псевдореализация

Показать много goroutine на небольшом числе OS threads.
Сравнить с pthreads и Python threading.
На C описать очередь задач, worker threads и кооперативное переключение.

48. GIL в CPython и его влияние на Python-потоки

Сравнить CPU-bound и I/O-bound задачи.
Показать, почему Python threads хороши для I/O, но ограничены для CPU-bound в CPython.
На C объяснить глобальную блокировку интерпретатора как mutex вокруг выполнения байткода.

49. Mutex: `pthread_mutex_t`, `sync.Mutex`, `threading.Lock`

Сравнить инкремент общего счетчика.
Показать race condition и исправление.
На C объяснить критическую секцию и блокировку на уровне ОС.

50. Atomic operations: C atomics, Go `sync/atomic`, Python ограничения

Сравнить атомарный счетчик.
C: <stdatomic.h>; Go: atomic.Int64/sync/atomic; Python: часто нужны locks или multiprocessing primitives.
На C объяснить memory ordering.

51. Каналы и очереди: Go channels, Python queue, C blocking queue

Показать producer-consumer.
Go: chan; Python: queue.Queue; C: mutex + condition variable.
На C реализовать кольцевой буфер с блокировкой.

52. `select`: Go `select`, C `select/poll/epoll`, Python selectors/asyncio

Сравнить ожидание нескольких источников событий.
Go: каналы; C: файловые дескрипторы; Python: event loop.
На C объяснить multiplexing ввода-вывода.

53. Async I/O: event loop в Python, goroutines в Go, неблокирующий C

Показать сетевой клиент.
Python: async/await; Go: синхронный код поверх рантайма; C: non-blocking sockets + event loop.
На C показать модель состояния соединения.

54. Отмена задач: context cancellation, flags, asyncio cancellation

Go: context.Context; Python: cancellation в asyncio; C: атомарный флаг или pipe/eventfd.
Показать graceful shutdown.
На C объяснить, почему безопасная отмена потока сложна.

Блок VII. Рантаймы, компиляторы и внутреннее устройство языков

55. Как CPython представляет объект: `PyObject`, refcount, type pointer

Показать Python int, str, list и их C-структуры концептуально.
Сравнить с Go value/interface и C struct.
На C написать мини-PyObject с полями refcnt и type.

56. Как Python выполняет байткод

Показать простой Python-код, его байткод и выполнение инструкций.
Сравнить с машинным кодом C и Go.
На C написать мини-интерпретатор цикла switch(opcode).

57. Как Go представляет interface

Показать присваивание конкретного типа в interface.
Сравнить с C vtable и Python duck typing.
На C смоделировать interface как {type_info, data_pointer, method_table}.

58. Как Go slice устроен внутри

Показать append, рост capacity, передачу slice в функцию.
Сравнить с C {ptr, len, cap} и Python list.
На C реализовать динамический массив с len/cap.

59. Как Python list устроен внутри

Показать append, индексацию, срезы.
Сравнить с Go slice и C dynamic array.
На C реализовать массив указателей на объекты с over-allocation.

60. Как hash map/dict устроены в Go, Python и C

Сравнить map[string]int, dict, собственную hash table на C.
Показать hash, bucket, collision, resize.
На C реализовать простую таблицу с открытой адресацией или chaining.

61. Сборка мусора: Go tracing GC, CPython refcount + cyclic GC, C manual memory

Сравнить создание циклических структур.
Python: refcount не удалит цикл без cyclic GC; Go: tracing GC найдет недостижимые объекты; C: программист сам освобождает.
На C реализовать мини mark-and-sweep.

62. Стек вызовов: C stack, goroutine stack, Python frames

Показать рекурсивную функцию.
Сравнить переполнение стека, traceback и panic stack trace.
На C объяснить stack frame, return address, local variables.

63. FFI: как языки вызывают C

Python: ctypes, C extension, CFFI.
Go: cgo.
C: экспорт функций через ABI.
Показать одну C-функцию, вызываемую из Go и Python.

Блок VIII. Ввод-вывод, сеть, форматы данных, системное программирование

64. Консольный ввод-вывод: stdin, stdout, stderr

Сравнить scanf/printf, fmt.Scan/fmt.Println, input/print.
Показать ошибки форматирования и парсинга.
На C объяснить потоки FILE* и буферизацию.

65. Работа с аргументами командной строки

C: argc/argv; Go: os.Args, flag; Python: sys.argv, argparse.
Показать CLI-утилиту с параметрами.
На C объяснить, как ОС передает аргументы процессу.

66. Переменные окружения и конфигурация

Сравнить чтение PATH, HOME, DATABASE_URL.
C: getenv; Go: os.Getenv; Python: os.environ.
На C объяснить окружение процесса как массив строк.

67. Файловая система: stat, path, directory traversal

Сравнить обход директории.
C: opendir/readdir/stat; Go: os, filepath.WalkDir; Python: os, pathlib.
На C объяснить inode, file descriptor и metadata.

68. Оптимизация циклов и структур данных

Сравнить ручной цикл в C, Go loop, Python loop и Python built-ins.
Показать, почему Python-цикл часто медленнее, а встроенные операции быстрее.
На C объяснить cache locality, branch prediction и vectorization.

ДЛЯ ГРУППЫ ГДЕ 27 человек (108 докладов)

Блок I. Синтаксис C как база, Go и Python как сравнение

1. Translation unit в C, package в Go, module в Python

Студент показывает один файл программы в трех языках.
C: .c-файл как единица компиляции.
Go: package main.
Python: модуль как исполняемый файл.
На C объясняется, что компилятор видит один translation unit после препроцессора.

2. `#include` в C, `import` в Go, `import` в Python

C: текстовая подстановка заголовка.
Go: импорт скомпилированного пакета.
Python: поиск и выполнение модуля.
На C вручную показывается, почему #include не равен импорту Python/Go.

3. Объявление и определение

C: declaration и definition.
Go: объявление переменной, функции, типа.
Python: имя появляется при присваивании.
Студент показывает, почему в C можно объявить функцию до реализации.

4. Точка входа и порядок выполнения

C: main.
Go: main.main.
Python: выполнение сверху вниз и if __name__ == "__main__".
На C объясняется startup code перед main.

5. Комментарии, блоки и стиль форматирования

C/Go: {}.
Python: отступы.
C: //, /* */; Python: #.
Студент показывает, как синтаксис влияет на парсер.

6. Переменная как ячейка памяти, имя как ссылка

C: переменная — область памяти фиксированного типа.
Go: переменная статического типа.
Python: имя указывает на объект.
На C моделируется Python-переменная как PyObject *name.

7. Инициализация переменных

C: неинициализированная локальная переменная может содержать мусор.
Go: zero value.
Python: имя должно быть связано с объектом.
Студент показывает три версии ошибки чтения до инициализации.

8. Области видимости

C: block scope, file scope.
Go: block scope, package scope.
Python: local, global, nonlocal, builtins.
На C реализуется таблица символов для простой функции.

9. Shadowing: затенение имен

C, Go и Python допускают разные формы shadowing.
Студент показывает один пример с x во внешнем и внутреннем блоке.
На C объясняется, что это разные записи в таблице символов.

Блок II. Типы, литералы, операторы

10. Целые типы C как основа понимания Go и Python

C: char, short, int, long, long long.
Go: int, int32, uint64.
Python: int произвольной точности.
На C моделируется Python int как объект с массивом машинных слов.

11. Signed и unsigned

C: signed int, unsigned int.
Go: int, uint.
Python: нет отдельного unsigned-типа для обычного int.
Студент показывает переполнение и сравнение отрицательного с unsigned.

12. Вещественные числа

C: float, double, long double.
Go: float32, float64.
Python: float как C double.
На C объясняется IEEE 754.

13. Символ, байт, rune, Unicode character

C: char как байт.
Go: byte и rune.
Python: str как Unicode-строка.
Студент показывает кириллицу и разную длину в байтах/символах.

14. Boolean-типы

C: _Bool, stdbool.h.
Go: bool.
Python: bool как подкласс int.
На C моделируется Python True/False как singleton-объекты.

15. `NULL`, `nil`, `None`

C: NULL — нулевой указатель.
Go: nil для pointer, slice, map, chan, func, interface.
Python: None — объект.
На C пишется структура NoneObject.

16. Арифметические операторы

C, Go, Python: +, -, *, /, %.
Показать отличия целочисленного деления.
На C реализовать функцию, повторяющую Python // для отрицательных чисел.

17. Логические операторы

C/Go: &&, ||, !.
Python: and, or, not.
Студент показывает short-circuit evaluation.
На C реализуется ручная ленивость через callback.

18. Побитовые операторы

C: &, |, ^, ~, <<, >>.
Go: те же идеи.
Python: работает с произвольно большими int.
На C показывается маска флагов и аналог Python set of flags.

Блок III. Управляющие конструкции

19. `if` как условный переход

C: if (cond).
Go: if cond.
Python: if cond:.
На C объясняется, как условие превращается в branch.

20. `if` с коротким объявлением в Go

Go: if x := f(); x > 0.
C: отдельное объявление перед if.
Python: walrus operator :=.
На C имитируется область жизни временной переменной.

21. `switch` в C, `switch` в Go, `match` в Python

C: fallthrough по умолчанию.
Go: break по умолчанию.
Python: structural pattern matching.
На C показывается jump table и ручной pattern matching.

22. `for` как главный цикл C и Go

C: for(init; cond; post).
Go: for init; cond; post.
Python: for по iterator.
На C реализуется iterator loop вручную.

23. `while` и бесконечный цикл

C: while, for(;;).
Go: for.
Python: while True.
На C показывается цикл как label + goto.

24. `break`, `continue`, `goto`

C: есть goto.
Go: есть labeled break/continue и goto с ограничениями.
Python: нет goto.
Студент показывает state machine, где C goto уместен.

25. `defer` Go через C cleanup stack

Go: defer.
C: goto cleanup или стек cleanup-функций.
Python: with/finally.
На C реализуется мини-defer.

26. `try/except/finally`, `panic/recover`, `setjmp/longjmp`

Python: исключения.
Go: panic/recover.
C: setjmp/longjmp.
Студент показывает, почему в C это опасно для ресурсов.

27. Pattern matching Python через C и Go

Python: match.
Go: switch + type switch.
C: enum tag + union + switch.
На C реализуется tagged union для AST-узлов.

Блок IV. Указатели, адреса, ссылки

28. Адрес переменной

C: &x.
Go: &x.
Python: прямого адреса нет, есть id(obj).
На C показывается, что Python-name хранит PyObject*.

29. Разыменование

C: *p.
Go: *p.
Python: автоматическая работа со ссылками.
На C моделируется доступ к Python-объекту через указатель.

30. Pointer arithmetic

C: p + 1.
Go: запрещено.
Python: отсутствует.
Студент показывает, почему pointer arithmetic мощен и опасен.

31. Указатель на указатель

C: int **p.
Go: **int возможно, но редко.
Python: имя на объект, контейнер хранит ссылки.
На C показывается изменение указателя внутри функции.

32. Указатель на функцию

C: int (*f)(int).
Go: func(int) int.
Python: функция как объект.
На C моделируется Python callable.

33. `void*` как универсальная ссылка

C: void*.
Go: any / interface{}.
Python: любой объект.
На C показывается потеря типа и ручной downcast.

34. `const` pointer и pointer to const

C: const int *p, int *const p.
Go: нет const для переменных.
Python: нет const, только соглашения и immutability объектов.
Студент показывает API, защищающий данные от изменения.

35. Dangling pointer

C: указатель на освобожденную память.
Go: GC и escape analysis снижают риск.
Python: объект живет при наличии ссылок.
На C демонстрируется use-after-free.

36. Null pointer dereference

C: segfault.
Go: panic.
Python: AttributeError у None.
На C пишется безопасная проверка перед разыменованием.

Блок V. Массивы, slice, list

37. Статический массив C

C: int a[10].
Go: [10]int.
Python: list не является статическим массивом.
На C объясняется contiguous memory.

38. Массив как параметр функции

C: array decay to pointer.
Go: array передается по значению.
Python: list передается как ссылка на объект.
Студент показывает изменение элемента внутри функции.

39. Размер массива

C: sizeof(a) / sizeof(a[0]) работает только в той же области.
Go: len(a).
Python: len(list).
На C показывается, почему в функцию надо передавать длину.

40. Go slice через C-структуру

Go: []int.
C: {ptr, len, cap}.
Python: list как динамический массив ссылок.
Студент реализует slice_get, slice_set, slice_append.

41. Python list через C-структуру

Python list хранит массив PyObject*.
Go slice хранит значения или указатели в underlying array.
C dynamic array хранит то, что укажет программист.
Студент реализует PyListLike.

42. `append` и рост capacity

C: realloc.
Go: append.
Python: list.append.
На C реализуется стратегия роста capacity.

43. Срезы

C: pointer + length.
Go: s[i:j] как view.
Python: lst[i:j] как новый list.
Студент показывает aliasing в Go и его отсутствие в Python list slice.

44. Копирование массивов и списков

C: memcpy.
Go: copy.
Python: list.copy, [:].
На C показывается shallow copy для массива указателей.

45. Удаление и вставка

C: memmove.
Go: append(s[:i], s[i+1:]...).
Python: del, insert.
Студент показывает стоимость O(n).

Блок VI. Строки и байты

46. C string как `char*`

C: строка заканчивается \0.
Go: string знает длину.
Python: str — Unicode object.
На C реализуется strlen.

47. Безопасное копирование строк

C: опасные strcpy, безопаснее snprintf.
Go: строки immutable.
Python: строки immutable.
Студент показывает переполнение буфера и безопасную альтернативу.

48. UTF-8

C: просто байты.
Go: range по rune.
Python: str уже Unicode, bytes отдельно.
На C реализуется подсчет UTF-8 code points.

49. Mutable buffer

C: char buf[256].
Go: []byte.
Python: bytearray.
Студент показывает изменение буфера на месте.

50. String builder

C: dynamic char buffer.
Go: strings.Builder.
Python: ''.join(parts).
На C реализуется builder с capacity.

51. Split и join

C: ручной парсер.
Go: strings.Split, strings.Join.
Python: split, join.
Студент пишет C-функцию, возвращающую dynamic array строк.

52. Substring view

C: StringView {ptr, len}.
Go: substring как slice байтов строки.
Python: новая строка.
Студент объясняет владение памятью у view.

53. Interning строк

C: hash table строк.
Go: вручную через map.
Python: некоторые строки интернируются.
На C реализуется string interner.

54. Строка как объект CPython

Python: PyUnicodeObject.
C: упрощенная структура с refcount, type, length, data.
Go: string header {data, len}.
Студент сравнивает накладные расходы.

Блок VII. Struct, union, enum, layout

55. `struct` в C как фундамент ООП

C: поля и layout.
Go: struct.
Python: class/dataclass.
Студент показывает User во всех трех языках.

56. `typedef struct`

C: именование пользовательского типа.
Go: type User struct.
Python: class name.
На C объясняется отличие имени struct tag и typedef alias.

57. Вложенные структуры

C: struct внутри struct.
Go: embedded или named field.
Python: объект содержит другой объект.
Студент показывает композицию.

58. `enum`

C: enum Status.
Go: const + iota.
Python: Enum.
На C показывается tagged status.

59. `union`

C: несколько представлений одной памяти.
Go: прямого union нет.
Python: объект может быть любого типа.
Студент реализует Value как enum tag + union.

60. Bit fields

C: битовые поля в struct.
Go: маски и сдвиги.
Python: int + маски.
Студент показывает packed flags.

61. Alignment и padding

C: sizeof, _Alignof.
Go: unsafe.Sizeof, alignment.
Python: объектные накладные расходы.
Студент меняет порядок полей и сравнивает размер.

62. Массив структур против структуры массивов

C: AoS vs SoA.
Go: []User vs отдельные slices.
Python: list объектов vs отдельные lists.
На C объясняется cache locality.

63. Opaque struct

C: скрыть поля в .c, оставить typedef в .h.
Go: неэкспортируемые поля.
Python: _private как соглашение.
Студент проектирует публичный API.

Блок VIII. Функции, методы, callback, closure

64. Сигнатура функции

C: тип результата и параметров.
Go: сигнатура с типами.
Python: динамические параметры + annotations.
Студент показывает одну функцию add.

65. Передача по значению

C и Go копируют значение.
Python передает object reference.
Студент показывает изменение int и объекта.

66. Out-параметры

C: int parse(const char*, int *out).
Go: value, err.
Python: return tuple или exception.
Студент реализует C-стиль в Go/Python вручную.

67. Variadic functions

C: stdarg.h.
Go: ...T.
Python: *args, **kwargs.
На C показывается опасность printf.

68. Callback

C: function pointer.
Go: function value.
Python: callable.
Студент пишет filter для массива.

69. Closure

Go и Python: захват переменных.
C: структура состояния + function pointer.
Студент реализует счетчик make_counter.

70. Method как функция с receiver

C: user_rename(User *self, ...).
Go: func (u *User) Rename(...).
Python: def rename(self, ...).
Студент показывает, что self — это первый аргумент.

71. Bound method

Python: obj.method связывает self.
Go: method value связывает receiver.
C: структура {object, function}.
Студент реализует bound method на C.

72. Function object

Python-функция — объект.
Go-функция может иметь environment.
C: struct Callable { void *env; fnptr call; }.
Студент реализует универсальный callable.

Блок IX. Python ООП через C и Go

73. Python class

Python: class User.
Go: struct + methods.
C: struct + vtable/type descriptor.
Студент показывает эквивалент класса без синтаксиса class.

74. `init` и конструкторы

Python: __init__.
Go: NewUser.
C: user_new, user_init.
На C показывается выделение и инициализация.

75. Instance attributes

Python: self.name.
Go: struct field.
C: struct field или dictionary атрибутов.
Студент реализует динамический attrs на C.

76. Class attributes

Python: атрибут класса общий.
Go: package variable.
C: поле в type descriptor.
Студент показывает общий счетчик экземпляров.

77. Method lookup

Python: instance → class → base classes.
Go: статически известный method set.
C: поиск в vtable/dict.
Студент реализует lookup метода по строке.

78. Inheritance

Python: наследование классов.
Go: embedding как близкий прием.
C: базовая struct первым полем дочерней struct.
Студент показывает Admin extends User.

79. Overriding

Python: переопределение метода.
Go: метод внешнего типа перекрывает promoted method.
C: заменить function pointer в vtable.
Студент реализует describe().

80. `super()`

Python: super().method().
Go: явный вызов embedded field.
C: вызов метода из base vtable.
Студент показывает ручной MRO-упрощенный механизм.

81. Multiple inheritance

Python: множественное наследование и MRO.
Go: embedding нескольких типов.
C: несколько embedded base structs или composition.
Студент показывает конфликт методов.

Блок X. Go ООП через C и Python

82. Go struct methods

Go: методы без классов.
Python: class methods.
C: функции с self.
Студент показывает, что Go ООП строится на типах и методах.

83. Value receiver vs pointer receiver

Go: копия или изменение оригинала.
C: struct by value или pointer.
Python: всегда object reference.
Студент демонстрирует ошибку с копией.

84. Interface

Go: interface satisfied implicitly.
Python: duck typing.
C: vtable нужной формы.
Студент реализует Reader на C.

85. Interface representation

Go interface как {type, data} или {itab, data} в модели.
Python object как {refcnt, type, ...}.
C: struct с typeinfo и data pointer.
Студент показывает dispatch.

86. Nil interface

Go: typed nil внутри interface.
Python: None.
C: interface с type != NULL, но data == NULL.
Студент показывает классическую ошибку err != nil.

87. Type assertion

Go: x.(T).
Python: isinstance.
C: проверка type_id.
Студент реализует безопасный downcast.

88. Type switch

Go: switch v := x.(type).
Python: match или isinstance.
C: switch(type_id).
Студент обрабатывает разные сообщения.

89. Embedding

Go: embedded struct.
Python: inheritance/composition.
C: вложенная struct и wrapper-методы.
Студент показывает promoted fields.

90. Generics Go

Go: Stack[T].
C: macros или void*.
Python: dynamic list + type hints.
Студент реализует generic stack тремя способами.

Блок XI. Коллекции: map, dict, set, queue

91. Hash table на C

C: массив buckets.
Go: map.
Python: dict.
Студент реализует put/get/delete.

92. Hash function

C: строковый hash.
Go/Python: hash скрыт в runtime.
Студент показывает, почему ключ должен быть hashable/comparable.

93. Collision resolution

C: chaining или open addressing.
Go: buckets.
Python: probing.
Студент показывает несколько ключей с одинаковым hash.

94. Resize hash map

C: rehash вручную.
Go/Python: runtime делает автоматически.
Студент реализует рост таблицы.

95. Set

C: hash table без значения.
Go: map[T]struct{}.
Python: set.
Студент удаляет дубликаты из массива.

96. Ordered dict behavior

Python dict сохраняет порядок вставки.
Go map не гарантирует порядок.
C: hash table + linked list порядка.
Студент реализует ordered map.

97. Queue

C: ring buffer.
Go: slice или channel.
Python: collections.deque.
Студент реализует очередь фиксированной и растущей capacity.

98. Linked list

C: nodes + pointers.
Go: struct nodes или container/list.
Python: класс Node.
Студент показывает владение памятью узлов.

99. Heap / priority queue

C: binary heap в массиве.
Go: container/heap.
Python: heapq.
Студент реализует push/pop.

Блок XII. Память, ресурсы, рантайм, итоговые проекты

100. `malloc`, `calloc`, `realloc`, `free`

C: ручное управление памятью.
Go: new, make, GC.
Python: allocator CPython.
Студент пишет C-обертку с проверкой ошибок.

101. Ownership API

C: create/destroy.
Go: владение через соглашения.
Python: GC и context manager.
Студент проектирует API без утечек.

102. Reference counting

C: свой RcObject.
Python: CPython refcount.
Go: tracing GC вместо refcount.
Студент пишет inc_ref/dec_ref.

103. Mark-and-sweep GC

C: мини-GC.
Go: tracing garbage collector концептуально.
Python: cyclic GC поверх refcount.
Студент реализует игрушечный mark phase.

104. File resource

C: FILE*.
Go: *os.File.
Python: file object.
Студент открывает, читает, закрывает файл с обработкой ошибок.

105. Error handling architecture

C: return codes.
Go: error.
Python: exceptions.
Студент строит слой repository → service → CLI.

106. Абстрактные классы Python, интерфейсы Go и их реализация на C через `struct + vtable`

Основная идея доклада

Сравнить три подхода к описанию “контракта поведения”:

Python	Go	C
`abc.ABC`, `@abstractmethod`	`interface`	`struct` с таблицей function pointers
класс явно наследуется от абстрактного класса	тип неявно реализует интерфейс	объект вручную содержит указатель на vtable
проверка происходит во время выполнения	проверка в основном на этапе компиляции	проверка вручную программистом

Что студент должен объяснить

В Python абстрактный класс — это обычный класс с метаинформацией о том, какие методы обязательны.
В Go интерфейс — это набор методов; тип реализует интерфейс неявно, если имеет нужные методы.
В C интерфейса нет, поэтому он имитируется через:
- struct;
- указатель на таблицу функций;
- явный self;
- ручной dynamic dispatch.

107. Наследование Python, его реализация на C и имитация наследования в Go