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

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

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

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

Языки и фреймворки устаревают за 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

⚡️ Почему Repository поверх EF Core часто превращается в лишний слой

Многие .NET-проекты начинают с отдельных репозиториев:

GetPostsByUser(...)
GetPopularPosts(...)
GetPostsByCategory(...)
GetRecentViralPosts(...)

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

Проблема в том, что DbContext уже предоставляет возможности, близкие к Repository и Unit of Work. Дополнительный слой часто усложняет запросы, скрывает возможности EF Core и создаёт абстракцию поверх абстракции.

Один из вариантов решения — Specification Pattern.

Каждая спецификация описывает отдельное условие выборки:

var specification =
    new ViralPostSpecification(minLikesCount: 150);

var posts = await dbContext.Posts
    .ApplySpecification(specification)
    .Select(post => post.ToDto())
    .ToListAsync(cancellationToken);

Спецификации можно переиспользовать и комбинировать:

var combinedSpec =
    recentSpec.And(highEngagementSpec);

Что это даёт:

- фильтры не размножаются по репозиториям
- запросы остаются рядом с бизнес-правилами
- спецификации проще тестировать
- условия можно комбинировать
- IQueryable продолжает переводиться в SQL

Repository Pattern полезен, когда действительно изолирует сложную инфраструктуру или несколько источников данных. Но создавать отдельный репозиторий для каждой сущности только ради шаблона часто означает лишнее усложнение архитектуры.

#dotnet #csharp #efcore #architecture

😨 Opus 5 собрал онлайн-шутер в духе Call of Duty практически с одного промпта

Автор попросил модель сделать FPS на Three.js с AAA-графикой, физикой и детализацией, а работу разбить между несколькими субагентами.

Отдельным агентам поручили:
• реализовывать разные части игры
• проверять результат визуально
• жёстко критиковать качество
• повторять итерации, пока результат не станет максимально близок к Call of Duty

Fвтор выложил репозиторий и исходный промпт, поэтому результат можно проверить самому.

промпт:

I want you to build a first-person shooter at the level of the most recent Call of Duty games. It should be utterly perfect, visually beautiful, with every single thing done at AAA quality—from textures to physics to anything you could think of.

Fan out sub-agents and have sub-agents tackle each one individually so that the game is utterly perfect. You should /loop on each item and have a separate sub-agent check it visually to ensure it looks triple A. That separate sub-agent should be a really harsh critic, and if it doesn't look triple A, it should keep going.

Don't stop until each sub-agent is utterly wowed with the quality when compared with the actual Call of Duty game. It should literally compare them side by side blind and say which one looks better. Do this in ThreeJS. /loop until it's utterly perfect. Fan out sub-agents and ultracode.

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

Геймдев меняется быстрее, чем многие ожидали. 😨

Каждый год в середине лета мы с друзьями собираемся на E-CODE. Ещё относительно молодая конфа Ozon Tech стала уже своего рода легендой. Не удивительно: хардовость официальной части здесь не уступает громкости афтерпати.

На E-CODE 2026 нас по части бэкэнда ждут:

• Runtime Async с его + и –
• трассировка с eBPF
• ускорение на SIMD
• построение кастомной real-time системы видеоаналитики
• сравнительный анализ алгоритмов сборки мусора

Фишка этого года — брейнринг разработчиков и ИИ. Эксперты разберут сложные кейсы и сравнят свои подходы с тем, что предложит машина. Победителя выберет зал.

Регистрируйтесь сейчас, чтобы услышать это всё вживую: https://ecode.ozon.tech/

12 и 13 сентября, Москва. До встречи на E-CODE!

Microsoft выпустила бесплатный курс по модернизации старого .NET

.NET Modernization for Beginners показывает, как перенести legacy ASP.NET-приложение на .NET 10 с помощью GitHub Copilot modernization agent.

Внутри:

- анализ старого кода и зависимостей;
- генерация плана миграции;
- пошаговый upgrade приложения;
- деплой обновлённой версии в Azure App Service.

Интересно, что агент сначала создаёт assessment.md, plan.md и tasks.md, а разработчик может проверить план до изменения кода.

Сам курс бесплатный и open source. Для практики понадобится GitHub Copilot.

https://devblogs.microsoft.com/dotnet/announcing-dotnet-modernization-for-beginners/

Copilot научили разбирать MSBuild-логи прямо в VS Code

Microsoft выпустила MSBuild Binlog Analyzer — расширение, которое превращает сложные .binlog в понятный диалог с GitHub Copilot.

Можно спросить:

почему упала сборка;
какие targets и tasks тормозят;
что изменилось между двумя сборками;
почему сломалась incremental build.

Copilot опирается на реальные данные лога через MCP, умеет находить причину ошибки, предлагать исправление и проверять результат повторной сборкой. Есть сравнение с baseline, поиск регрессий и загрузка логов из GitHub Actions и Azure DevOps.

https://devblogs.microsoft.com/dotnet/msbuild-binlog-analyzer-vscode/

Clean Code: сложный `if` лучше превратить в понятное правило

Такой код приходится расшифровывать каждый раз:

if (invoice is not null &&
    invoice.Status == InvoiceStatus.Unpaid &&
    invoice.DueDateUtc < DateTime.UtcNow &&
    invoice.Balance > 0 &&
    !invoice.SilenceWarnings &&
    invoice.Customer.Email is not null)
{
    SendOverdueWarning(invoice);
}

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

Вынесем правило в метод с говорящим именем:

if (invoice.ShouldSendOverdueWarning(nowUtc))
{
    SendOverdueWarning(invoice);
}

Само правило:

public bool ShouldSendOverdueWarning(DateTime nowUtc)
{
    return Status == InvoiceStatus.Unpaid
        && DueDateUtc < nowUtc
        && Balance > 0
        && !SilenceWarnings
        && Customer.Email is not null;
}

Теперь вызывающий код отвечает на вопрос что происходит, а метод хранит детали когда это разрешено.

### Почему исходный вариант плохо тестируется

Он напрямую использует DateTime.UtcNow. Результат зависит от реального времени, поэтому тест может вести себя по-разному в разные моменты.

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

[Fact]
public void Sends_warning_for_overdue_unpaid_invoice()
{
    var invoice = new Invoice
    {
        Status = InvoiceStatus.Unpaid,
        DueDateUtc = new DateTime(2026, 7, 20),
        Balance = 1500,
        SilenceWarnings = false,
        Customer = new Customer { Email = "[email protected]" }
    };

    var nowUtc = new DateTime(2026, 7, 28);

    Assert.True(invoice.ShouldSendOverdueWarning(nowUtc));
}

Для больших проектов вместо DateTime можно внедрить TimeProvider. Главное правило: время, сеть, файловая система и случайность не должны быть скрыты внутри бизнес-логики.

C# 15 наконец избавляет вложенные циклы от флагов и `goto`

break и continue могут указывать метку внешнего цикла. Это позволяет сразу выйти из нескольких уровней вложенности или перейти к следующей итерации нужного цикла.

outer: for (int row = 0; row < grid.Height; row++)
{
    for (int column = 0; column < grid.Width; column++)
    {
        if (grid[row, column].IsBlocked)
        {
            continue outer;
        }

        if (grid[row, column].IsGoal)
        {
            break outer;
        }
    }
}

Здесь:

- continue outer прекращает внутренний цикл и запускает следующую итерацию внешнего;
- break outer полностью выходит из обоих циклов.

Раньше для такого поведения приходилось использовать булевы флаги, дополнительные проверки или goto.

В C# 15 этот код можно записать короче и понятнее.

Особенно удобно при обходе:

- матриц;
- вложенных коллекций;
- игровых карт;
- таблиц;
- сложных структур данных.

Небольшое изменение, которое убирает много лишнего кода из вложенных циклов.

C#-приём: точное сложение `double` через алгоритм Кэхэна

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

Обычный вариант:

double sum = 0;

foreach (double value in values)
{
    sum += value;
}

Более точный вариант:

public static double KahanSum(ReadOnlySpan<double> values)
{
    double sum = 0;
    double compensation = 0;

    foreach (double value in values)
    {
        double adjusted = value - compensation;
        double next = sum + adjusted;

        compensation = (next - sum) - adjusted;
        sum = next;
    }

    return sum;
}

Переменная compensation сохраняет часть числа, потерянную при округлении, и возвращает её в следующее сложение.

Использование:

double[] values = { 0.1, 0.2, 0.3, 0.4 };

double result = KahanSum(values);

Метод полезен для:

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

ReadOnlySpan<double> позволяет передавать массивы и участки памяти без дополнительных копирований.

Алгоритм требует нескольких дополнительных операций на каждом шаге, зато заметно уменьшает накопленную погрешность.

Для денежных расчётов по-прежнему лучше использовать decimal. А когда нужна скорость double и повышенная численная устойчивость – пригодится Kahan Summation.

## В C# появился safe — но это не аналог Rust

В C# 15 тестируется новый контекстный модификатор safe для кода на границе с нативной памятью.

Главная проблема P/Invoke: компилятор видит сигнатуру метода, но не может проверить, насколько безопасно ведёт себя код внутри подключённой библиотеки. Теперь разработчик должен явно зафиксировать решение:

[LibraryImport("libc")]
internal static safe partial int getpid();

[LibraryImport("libc")]
internal static unsafe partial nuint strlen(byte* value);

safe означает, что вызов не требует `unsafe`-контекста со стороны пользователя API.

unsafe предупреждает: безопасность зависит от условий, которые компилятор проверить не может. Такой метод разрешено вызывать только внутри блока:

unsafe
{
    nuint length = strlen(pointer);
}

Та же логика применяется к полям структур с явным расположением памяти:

[StructLayout(LayoutKind.Explicit)]
struct Packet
{
    [FieldOffset(0)]
    public safe long Id;

    [FieldOffset(0)]
    public unsafe nint Pointer;
}

Если не указать ни safe, ни unsafe, компилятор выдаст ошибку при включённых новых правилах безопасности. :contentReference[oaicite:0]{index=0}

Важный нюанс: safe не анализирует нативный код и не доказывает его безопасность. Это явное обещание автора API, которое делает потенциально опасные границы заметными при ревью.

C# постепенно меняет подход к unsafe: риск должен быть обозначен в контракте метода и локализован в конкретных участках программы, а не спрятан внутри большого `unsafe`-класса.

Пока эта модель находится в preview и может измениться до стабильного выпуска C# 15.

Лето, ИТ-Пикник и музыка известных артистов уже через несколько дней!

8 августа в Коломенском пройдет ИТ-Пикник.

В программе — выступления проекта LAB Антона Беляева, IOWA, Cream Soda, Pompeya, мартина и Совы.

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

Зарегистрироваться и узнать подробности можно на сайте мероприятия.

В билет входит +1 — можно позвать близких и друзей.

До встречи в месте притяжения ИТ.