Совет по .NET Aspire: не воспринимайте его только как удобную локальную панель.

Самая полезная часть начинается, когда у приложения появляется инфраструктура: API, Postgres, Redis, фоновые сервисы, переменные окружения и connection strings.

Вместо того чтобы вручную собирать docker-compose.yml, опишите сервисы в AppHost. Aspire Docker publisher сможет сгенерировать Compose-артефакты из этой модели.

Но важно понимать границу: Aspire не деплоит приложение за вас.

Он не заменяет CI/CD, не управляет секретами и не переносит контейнеры на сервер. Вам всё равно нужно собрать image, задать реальные env-переменные, скопировать файлы и запустить Docker Compose.

Зато это хороший баланс: меньше ручной YAML-рутины, но без магии, которая скрывает реальную схему деплоя.

Задачка C#

Зачем указывать RunContinuationsAsynchronously у TaskCompletionSource?

A - Чтобы продолжения выполнялись синхронно при SetResult

B - Чтобы не исполнять продолжения синхронно в потоке SetResult, а планировать их асинхронно, избегая дедлоков и глубоких стеков

C- Чтобы запретить отмену задач

D- Чтобы обойти планировщик и ускорить завершение

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

На входе дерево:

1
2 3
4 5 6

Нужно не просто пройти узлы, а напечатать каждый уровень с новой строки.

Первое, что вспоминается, это BFS. Для обхода в ширину идеально подходит Queue<T>: кладём корень, достаём узел, добавляем его детей, повторяем.

Так легко получить порядок:

1 2 3 4 5 6

Но настоящая часть задачи начинается дальше: как понять, где закончился уровень?

Есть два нормальных варианта:

• хранить вместе с узлом его уровень
• на каждой итерации брать queue.Count и обрабатывать ровно столько узлов текущего уровня

Второй способ часто чище: размер очереди в начале цикла и есть количество элементов на текущем уровне.

Такие задачи редко проверяют «знание деревьев ради деревьев».

Они проверяют другое: умеешь ли ты разложить проблему, выбрать структуру данных и аккуратно контролировать состояние.

Для C# это отличный мини-тест на мышление, работу с Queue<T> и понимание алгоритмов без магии фреймворков.

Globbing. - это удобный способ искать файлы по маскам, без ручного перебора папок и костылей со строками.

Например:

**/*.cs - все C# файлы во всех вложенных папках
wwwroot/**/*.js - все JS-файлы внутри wwwroot
!bin/** и !obj/** - исключить мусорные директории сборки

Где это полезно:

• генерация списков файлов
• поиск конфигов
• обработка шаблонов
• сборка ассетов
• утилиты для проектов
• backend/frontend tooling

Это не Regex. Globbing проще, читаемее и отлично подходит для файловой структуры.

Backend пример:
https://github.com/karenpayneoregon/vs2026-how-to/blob/f1c136c864b05ec9eec91e120997314d978b0966/CommonLibrary/GlobbingOperations.cs?plain=1#L6C15-L6C15

Frontend пример:
https://github.com/karenpayneoregon/vs2026-how-to/blob/f1c136c864b05ec9eec91e120997314d978b0966/ExperimentsApp/Classes/GlobbingCode.cs?plain=1#L20C37-L20C37

# C# record: что выведет код?

На собеседованиях record часто объясняют как «сравнение по значению». Но есть нюанс, который легко пропустить.

public record User(string Name, List<string> Roles);

var u1 = new User("Alice", new List<string> { "admin" });

var u2 = u1 with { };

u2.Roles.Add("owner");

Console.WriteLine(u1 == u2);
Console.WriteLine(string.Join(", ", u1.Roles));
Console.WriteLine(ReferenceEquals(u1.Roles, u2.Roles));

Что будет в консоли?

True
admin, owner
True

Почему так?

with для record делает не глубокую копию, а поверхностную. Сам объект User скопировался, но List<string> внутри остался тем же самым объектом в памяти.

Поэтому изменение u2.Roles меняет и u1.Roles.

И сравнение тоже остаётся True, потому что оба record указывают на один и тот же список.

Вот почему record не делает модель автоматически immutable. Он только упрощает синтаксис и даёт value-based equality. Если внутри лежат изменяемые reference-типы, их всё равно можно случайно протащить в состояние.

Более безопасный вариант:

public record User(string Name, IReadOnlyList<string> Roles);

А для строгой неизменяемости лучше смотреть в сторону immutable collections.

Godot фактически запрещает vibe coding в контрибуциях.

Причина простая: PR стало легче генерировать, но не легче проверять. Для open-source движка каждый патч всё равно должен разобрать мейнтейнер, который понимает архитектуру, риски и последствия изменений.

Теперь автономные агенты, крупные AI-сгенерированные куски кода и сгенерированный текст в issues, proposals и PR-дискуссиях запрещены. Разрешены только мелкие помощники вроде автодополнения, regex и find/replace. Помощь AI в коде нужно раскрывать.

На практике правило будет сложно применять: почти невозможно наверняка доказать, где был vibe coding, а где обычная работа разработчика.

Godot защищает не стиль разработки, а время ревьюеров. Код можно сгенерировать за минуты, но ответственность за него всё равно остаётся на людях.

godotengine.org/article/contribution-policy-2026/

Ты не твой стек

Зачем учиться новому, когда по самое колено в практике? Не страшно, что всё больше джунов работают наравне с сеньёрами?

Уже нельзя уметь только фреймворк, надо понимать что стоит за этим и в твоём опыте огромное преимущество, не хватает лишь малого - знаний об том как утроен мир и формула принятия решений.

Метафизика? Нет - математика.

Языки и фреймворки устаревают за 5–10 лет, стеки обновляются радикально. А способ мышления, которым ты пользуешься, чтобы разложить сложную задачу на части, остаётся с тобой навсегда.

Именно об этом курс: "Философия, математика и компьютерные науки"

Не про конкретный стек, а про то, как в принципе думать о сложных системах с опорой на философию, математику и системную инженерию.

Формат:
9 месяцев, 10 модулей, теория и практика, несколько очных сессий в Петербурге.

Кураторы:
- Андрей Родин — доктор философских наук, философ науки и математики
- Илья Егорычев — доктор философских наук, математик и логик, Soulmaths
- Вячеслав Шириков — системный архитектор, техдиректор ГК «Лартех»

До 21 июля действует скидка за раннюю регистрацию.
Программа и условия

G# — новый язык для .NET с синтаксисом ближе к Go, Kotlin и Swift.

Идея не в том, чтобы заменить C#, а в том, чтобы дать более компактный язык поверх той же CLR.

Что обещают:

• компиляция в обычные managed .NET assemblies

• совместимость с BCL, NuGet, MSBuild и dotnet tooling

• interop с C#-кодом

• null-safety через T?, nil, ?., ??, if let и guard let

• data classes со structural equality, copy-with и deconstruction

• async/await поверх Task и Task[T]

• опциональные Go-подобные go, chan, select

• REPL / script runner через gsi

• C# → G# мигратор через cs2gs

Самая интересная часть — G# не пытается строить новый рантайм. Он просто использует существующую .NET-экосистему и меняет язык входа: меньше исторического багажа C#, больше предсказуемой синтаксической поверхности.

Но важно: проект пока pre-1.0. Версия 0.3 — это скорее milestone по реализации и interop, а не гарантия стабильности языка.

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

Статья: https://www.linkedin.com/pulse/meet-g-modern-net-language-go-kotlin-swift-ergonomics-david-obando-lwofc/

TIME_WAIT в Linux годами объясняют неправильно

Я полез в исходники Linux TCP и снова наткнулся на старый сетевой миф.

В коде TIME_WAIT фактически зафиксирован на 60 секунд:
#define TCP_TIMEWAIT_LEN (60 * HZ)
Его нельзя настроить отдельно для сокета.

И да, tcp_fin_timeout, который часто советуют крутить в блогах, не управляет TIME_WAIT.

Он относится к состоянию FIN_WAIT2.

TIME_WAIT задан в исходниках ядра и не вынесен в отдельный sysctl.

Вот так появляются мифы: один параметр звучит похоже, его копируют из статьи в статью, а потом годами лечат не то состояние TCP.

Vertical Slice Architecture хороша тем, что перестаёт заставлять код жить “по этажам”.

В классической слоистой архитектуре фича часто размазана по всему проекту: endpoint в одном месте, request/response в другом, validator где-то рядом, handler отдельно, репозиторий ещё ниже. Чтобы понять одну бизнес-операцию, приходится прыгать по папкам как по квесту.

В vertical slice подход другой: одна фича — один самостоятельный срез.

Например, CreateProduct может хранить рядом всё, что нужно именно для создания продукта:
request, response, validator, endpoint и handler с бизнес-логикой.

Не потому что “так модно”, а потому что это проще сопровождать.

Открыл срез - сразу видишь, что принимает API, что возвращает, как валидирует входные данные и что реально делает. Меньше магии, меньше лишней навигации, меньше риска случайно сломать соседнюю фичу.

Для больших проектов это очень удобно: код начинает группироваться не вокруг технических слоёв, а вокруг бизнес-сценариев.

И это, кажется, главный плюс VSA.

Архитектура становится ближе к тому, как продукт реально работает.

🔥 Вышел .NET 11 Preview 6.

Это уже шестой превью-релиз .NET 11, и он выглядит не как “пара мелких фиксов”, а как большой проход по всему стеку: Runtime, SDK, Libraries, ASP.NET Core, MAUI, C#, EF Core, F#, контейнеры. Microsoft прямо перечисляет улучшения во всех этих направлениях.

Самое интересное для backend-разработчиков:

* улучшения JIT и runtime async performance
* in-process crash report logging
* faster interface dispatch для NativeAOT
* новые SIMD API
* dotnet test получает новые опции и улучшенный вывод
* container publishing теперь поддерживает multi-arch builds с Podman

В C# продолжают двигать union types: System.Text.Json уже умеет сериализовать C# union types, а support types для unions теперь идут “из коробки”. Ещё появился пункт про extension indexers.

В ASP.NET Core тоже много практичных вещей: async validation для minimal APIs, автоматическая CSRF-защита для cross-origin сценариев, OpenAPI 3.2 по умолчанию, unions в ASP.NET Core, обновления SignalR и short-circuit endpoints через attribute.

EF Core получил улучшения LINQ query translation, migrations, Cosmos DB provider и поддержку ключей/индексов через complex-type properties.

Для меня главный сигнал Preview 6 такой: .NET 11 явно допиливают не только как runtime, а как цельную платформу для production-разработки: performance, NativeAOT, контейнеры, web API, тесты и tooling двигаются вместе.

Ставить в прод пока рано, но смотреть и пробовать уже есть что.

https://devblogs.microsoft.com/dotnet/dotnet-11-preview-6/

Microsoft показала Microsoft.UI.Reactor - экспериментальный open-source проект, который переосмысляет разработку WinUI 3-приложений.

Инструмент позволяет писать нативные Windows-приложения декларативно на C#, без привычной связки XAML + code-behind + view models. UI описывается как функция состояния, а Reactor сам синхронизирует экран с изменениями.

Что это даёт:

* меньше split между разметкой и логикой
* проще управлять state
* компоненты выглядят ближе к React-подходу
* вся структура приложения остаётся в C#
* можно быстрее собирать и менять UI

Проект пока экспериментальный. В README он описан как набор расширений для WinUI 3, а публичный preview-пакет уже доступен через NuGet; шаблон проекта пока ставится из исходников.

На фоне того, что WinUI 3 остаётся рекомендуемым нативным UI-фреймворком для новых Windows desktop-приложений, Reactor выглядит как попытка сделать Windows-разработку более современной и менее тяжёлой.

Это интересный эксперимент: каким мог бы быть WinUI, если бы его проектировали под декларативный C# и component-driven разработку.

build.microsoft.com/en-US/sessions/OD854?source=sessions

Unity представила Unity CLI - инструмент, который позволяет ИИ-агентам напрямую работать с игровыми проектами.

Агент может:

- изменять объекты и компоненты в сценах;
- искать причины ошибок;
- исправлять баги;
- запускать сборку проекта;
- проверять, действительно ли исправление сработало.

В одном из демо агент получил баг-репорт о персонаже, проваливающемся сквозь пол. Он самостоятельно нашёл отключённый коллайдер, активировал его, запустил проверку и убедился, что проблема исчезла.

Получается почти полноценный ИИ-разработчик: получил задачу, изучил проект, внёс изменения и протестировал результат — всё через терминал.

Инструмент доступен бесплатно.

Подробнее: https://unity.com/blog/meet-the-unity-cli

#unity #gamedev #ai #vibecoding