День 1307. #Книги
Прочитал книгу «Принципы юнит-тестирования» (Владимир Хориков — СПб.: Питер, 2022).

Книга в целом понравилась. Хорошо расставляет по местам имеющиеся знания о тестировании и добавляет логические связи. Это мне в книгах нравится больше всего – ощущение, что пазл из твоих обрывочных знаний собирается вместе, дополняется недостающими частичками и складывается в единую картину.

В книге довольно подробно описана теория: что такое тесты, какие они бывают, из чего состоят, зачем их делать и какие правила стоит соблюдать, а чего лучше не делать (например, что не стоит гнаться за метриками покрытия кода). Вообще, на канале отрывков из книги приводилось уже довольно много. Их можно найти по тегу #Testing. А вот здесь есть даже шпаргалка по юнит-тестам, по мотивам книги.

Что не совсем понравилось. На мой взгляд примеры в книге слишком упрощены. Я понимаю, что невозможно в печатном издании приводить многостраничные листинги кода. Но, например, в книге «Внедрение зависимостей на платформе .NET», на которую Владимир частенько ссылается, авторам удалось привести примеры реальных приложений и реальных проблем, с которыми можно столкнуться. Здесь же, как мне показалось, примеры приводятся слишком простые, и часто за ними следует фраза вроде «понятно, что в реальных системах всё будет намного сложнее».

В чём я лично вижу проблему с переупрощёнными примерами. Требуется опыт, чтобы придумать, где это будет применено в реальности. А это нужно, чтобы кусочек пазла встал на своё место. У меня с этим проблем не возникло, потому что я в последнее время всерьёз занялся внедрением тестов на своей основной работе (собственно, поэтому и книгу приобрёл). Я уже столкнулся с большинством описанных препятствий, поэтому у меня они «легли в контекст», и я довольно часто ловил себя на мысли «а, так вот как это надо было делать». Или же я легко представлял, где я смогу это использовать.

Однако у человека, не имеющего хотя бы небольшого опыта в тестировании серьёзного приложения, как мне кажется, может возникнуть проблема с обоснованием нужности того или иного утверждения из книги. А когда факт зависает вне контекста, не отвечая на вопрос «зачем?», он быстро забывается. Хотя, в этом случае можно посоветовать прочитать книгу, узнать основы, а затем перелистать её после получения некоторой реальной практики (и пары шишек).

День 1308. #ЗаметкиНаПолях
Принудительный HTTPS в Приложениях ASP.NET Core. Начало
Как заставить ваше приложение ASP.NET Core использовать только HTTPS? Изучаем лучшие практики для различных сценариев.

1. Использовать перенаправление HTTPS
Если клиент вызывает приложение, используя HTTP, приложение перенаправляет его на тот же URL-адрес, начинающийся с HTTPS. Перенаправление URL — хорошо известный подход. Веб-приложение создает ответ HTTP с кодом состояния, начинающимся с 3, и заголовком Location, как в следующем примере:

HTTP/1.1 301 Moved Permanently
Location: https://...

Этот подход не устраняет все риски безопасности, но является хорошей отправной точкой. К счастью, в ASP.NET Core есть несколько других вариантов.

2. Атрибут RequireHttps
Его можно использовать в приложениях, чтобы заставить страницу требовать HTTPS. В Razor Pages RequireHttps можно применять только к классам, страниц, либо к методам класса:

[RequireHttps]
public class PrivacyModel : PageModel 
{ … }

В ASP.NET Core MVC можно применить атрибут RequireHttps к классам, контроллеров или к их методам действия:

[RequireHttps]
public class HomeController : Controller
{ … }

Есть соблазн применять атрибут выборочно к определённым страницам или представлениям, таким образом ограничить HTTPS только страницами с конфиденциальным содержимым. Но смешивание страниц HTTP и HTTPS — очень плохая идея! Ваше приложение так подвергается атакам с понижением протокола. Это разновидность атак man-in-the-middle, когда HTTP запрос перехватывается атакующим, и таким образом компрометируется вся безопасность последующей коммуникации между клиентом и сервером.
Можно применить RequireHttps ко всем страницам, но есть и более простые способы.

3. Промежуточное ПО перенаправления на HTTPS
При создании веб-приложения с использованием одного из стандартных шаблонов проектов ASP.NET файл Program.cs (Startup.cs) содержит вызов метода UseHttpsRedirection() в конвейере промежуточного ПО:

…
app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();
…

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

4. Промежуточное ПО HSTS
К сожалению, принудительного переключения клиента с HTTP на HTTPS при каждом запросе может быть недостаточно для предотвращения атак с понижением протокола. Злоумышленник может перехватить HTTP-запрос клиента до того, как он переключится на соответствующий HTTPS-запрос.
Нужен способ указать браузеру обязательно использовать HTTPS для запроса любого ресурса веб-приложения. Это заголовок HTTP Strict-Transport-Security (HSTS). Имея заголовок HSTS, браузер будет вызывать ваше приложение с использованием HTTP только в самый первый раз. Последующие запросы к тому же домену будут выполняться через HTTPS, даже если в адресе будет HTTP. Включить HSTS можно с помощью метода UseHsts(). Этот вызов также уже включён в шаблоны веб-приложений ASP.NET Core:

if (!app.Environment.IsDevelopment())
{
  app.UseExceptionHandler("/Error");
  app.UseHsts();
}

По умолчанию поддержка HSTS отключена в вашей среде разработки. Скорее всего, вы используете localhost в качестве домена. Если вы используете HSTS, любой запрос, сделанный вашим браузером к локальному хосту, будет использовать HTTPS. Это является хорошей практикой. Но при этом браузер будет делать HTTPS-запросы к любому приложению, размещённому на локальном хосте. Это может вызвать проблемы, например с Angular приложениями.

Окончание следует…

Источник: https://auth0.com/blog/force-https-in-aspnet-core-apps/

День 1309. #ЗаметкиНаПолях
Принудительный HTTPS в Приложениях ASP.NET Core. Окончание
Начало

Перенаправление HTTPS и API
Подход с перенаправлением HTTPS основан на отправке обратно клиенту кода состояния 301 или другого 30* HTTP, независимо от того, используете ли вы атрибут RequireHttps или ПО промежуточного слоя для перенаправления HTTPS. Подход HSTS основан на отправке заголовка Strict-Transport-Security.

Оба подхода хорошо понимаются стандартными браузерами. Таким образом, на эти подходы могут полагаться типы приложений, клиентами которых являются браузеры, например приложения ASP.NET Core MVC, Razor Pages и Blazor Server.

Однако эти подходы обычно игнорируются небраузерными клиентами, такими как клиенты API. Мобильное приложение или SPA крайне редко заботятся о кодах состояния 301 или заголовках HSTS. В этом случае есть два альтернативных способа работы с клиентами, которые делают HTTP-запросы:

1. Игнорировать HTTP-запросы
Один из самых простых способов — использовать флаг --urls команды запуска dotnet, как показано ниже:

dotnet run --urls "https://localhost:7123"

Это переопределит настройки URL в файле Properties/launchSettings.json проекта ASP.NET Core.

В производственной среде можно задать переменную окружения ASPNETCORE_URLS.
PowerShell:

$Env: ASPNETCORE_URLS = "https://localhost:7123"

Bash:

export ASPNETCORE_URLS=https://localhost:7123

2. Выдавать на HTTP-запросы код ответа Bad Request
Для этого потребуется собственное промежуточное ПО вместо UseHttpsRedirection() и UseHsts():

//app.UseHttpsRedirection();
app.Use(async (context, next) => {
  if (!context.Request.IsHttps) {
    context.Response.StatusCode =
     StatusCodes.Status400BadRequest;
    
    await context
     .Response
     .WriteAsync("HTTPS required!");
  } 
  else {
    await next(context);
  }
});

Код выше просто проверяет, использует ли текущий запрос HTTPS. Если это не так, он отвечает кодом состояния 400 Bad Request и сообщением, предупреждающим, что требуется HTTPS.

Перенаправление HTTPS и обратные прокси
Все вышеизложенное имеет смысл, если ваше приложение ASP.NET Core напрямую подключено к Интернету. Если ваше приложение развернуто в среде с обратным прокси-сервером, который обеспечивает безопасность подключения, нет необходимости использовать перенаправление HTTPS или промежуточное ПО HSTS. В этом случае вы можете просто удалить вызовы методов UseHttpsRedirection() и UseHsts() из веб-приложений или собственное промежуточное ПО из примера выше для веб-API. Вы делегируете переключение с HTTP на HTTPS и управление ответами обратному прокси-серверу.

Источник: https://auth0.com/blog/force-https-in-aspnet-core-apps/

День 1310. #Карьера
С началом нового учебного года всех!
Лично для меня 1 сентября до сих пор остаётся днём старта чего-то нового. Стартует учебный год (теперь уже у детей), старт нового телесезона, старт многих осенне-весенних спортивных сезонов. В общем, повод выползать из отпускного настроения и приниматься за работу.

Поэтому сегодня поговорим о нашем злейшем враге – прокрастинации.

«По результатам многочисленных опросов, около 95% людей признают, что часто откладывают дела на потом.» (Остальные 5% просто врут).
- Пирс Стил «Уравнение прокрастинации»

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

Мы гораздо более склонны откладывать на потом, когда задача:
1. Скучная (например, написание документации).
2. Разочаровывающая или рутинная (например, изучение нового навыка).
3. Сложная (например, дебаг плавающей ошибки).
4. Неоднозначная или неструктурированная (например, подготовка к марафону или реализация большого проекта).
5. Не содержащая в себе вознаграждения (например, всё то же написание документации, зная, что её никто не будет читать).
6. Не имеющая ценности для вас лично (например, уборка домашнего офиса).

Чем больше этих атрибутов имеет задача, тем больше вероятность, что мы её отложим.

Постараемся побороть каждый из этих атрибутов.

1. Делайте скучные задачи более увлекательными. Если нужно писать документацию, пойдите в любимое кафе и сделайте это за чашкой какого-нибудь экзотического кофе. Если выполнение задачи не требует умственных усилий, скачайте интересную аудиокнигу или подкаст.
2. Установите ограничение по времени для разочаровывающих задач. Занимайтесь задачей в течение 20-30 минут, а дальше – как пойдёт. Сделайте из этого игру. К примеру, Microsoft Learn имеет для этого очки опыта и бейджи за каждый изученный навык.
3. Разбейте сложную задачу на более мелкие и составьте план работы. Работайте над самыми сложными задачами во время вашего биологического прайм-тайма (подробнее о нём тут). Кроме того, не стесняйтесь просить помощи.
4. Составьте план неоднозначных и неструктурированных задач. Например, потратьте 20 минут на то, чтобы наметить следующие шаги по проекту. Вычёркивайте выполненные пункты. Поищите примеры того, как другие справлялись с такими задачами.
5. Побалуйте себя, выполняя задачи, которые не содержат в себе вознаграждения. Например, откладывайте доллар (или любой эквивалент) на какой-нибудь ваш каприз за каждые 10 минут работы (работы, а не прокрастинации) над задачей.
6. Ищите позитивные стороны в задачах, не имеющих ценности для вас лично. Например, убранное рабочее место позволяет чувствовать себя более спокойно, организованно и работать более продуктивно.

А вот ещё 3 совета:
1. Составьте список задач на случай, когда поймаете себя на прокрастинации. Главное, чтобы эти задачи имели хоть какую-нибудь пользу и ценность для вас. Это позволит вернуть чувство продуктивности, если основная задача никак не решается. Можно заняться хоть чем-то полезным, пусть это будет даже наведение порядка в папках на компьютере, обновление IDE или написания маленького скрипта для автоматизации ежедневных рутинных действий. Но не слишком увлекайтесь.
2. Составьте список негативных последствий. Простое перечисление и осознание негативных последствий от несделанного дела – отличный мотиватор взяться за работу.
3. Просто начните. Поставьте таймер на 15 минут, после чего позволите себе остановиться и заняться чем-то другим. Иногда задача не настолько неприятная, как вам изначально казалось. Если через 15 минут вы чувствуете в себе силы продолжать – продолжайте.

Прокрастинация — это человеческий феномен: все на планете откладывают дела. В следующий раз, когда вы заметите, что откладываете что-то, обратите внимание на то, что заставляет вас отложить задачу и составьте простой план противодействия этому. В результате вы сделаете намного больше.

Источник: https://alifeofproductivity.com/what-triggers-procrastination/

День 1311. #ЗаметкиНаПолях #AsyncTips
Взаимодействие с другими системами отмены

Задача
Имеется внешний или унаследованный код с собственными концепциями отмены. Требуется управлять им с использованием стандартного объекта CancellationToken.

Решение
У типа CancellationToken существует два основных способа реакции на запрос на отмену: периодический опрос и обратные вызовы. Периодический опрос обычно используется для кода, интенсивно использующего процессор, — например, циклов обработки данных; обратные вызовы обычно используются во всех остальных ситуациях. Регистрация обратного вызова для маркера осуществляется методом CancellationToken.Register.

Допустим, вы пишете обертку для System.Net.NetworkInformation.Pingtype и хотите предусмотреть возможность отмены тестового опроса. Класс Ping уже имеет API на базе Task, но не поддерживает CancellationToken. Вместо этого тип Ping содержит собственный метод SendAsyncCancel, который может использоваться для отмены. Для этого зарегистрируйте обратный вызов, который активизирует этот метод:
async Task<PingReply> PingAsync(
string host,
CancellationToken ct)
{
using var ping = new Ping();
var task = ping.SendPingAsync(host);

using CancellationTokenRegistration _ =
ct.Register(() => ping.SendAsyncCancel());

return await task;
}

Теперь при запросе на отмену CancellationToken вызовет метод SendAsyncCancel за вас, отменяя метод SendPingAsync.

Метод CancellationToken.Register может использоваться для взаимодействия с любой альтернативной системой отмены. Но следует помнить, что, если метод получает CancellationToken, запрос отмены должен отменять только эту одну операцию. Некоторые альтернативные системы отмены реализуют отмену закрытием некоторого ресурса, что может привести к отмене нескольких операций; эта разновидность системы отмены плохо соответствует CancellationToken. Если вы решите инкапсулировать такую разновидность отмены в CancellationToken, следует документировать её необычную семантику отмены.

Помните о сроке существования регистрации обратных вызовов. Метод Register возвращает отменяемый объект, который должен быть освобожден, когда обратный вызов перестанет быть нужным. Предыдущий пример использует команду using для выполнения очистки при завершении асинхронной операции. Если в коде отсутствует команда using, то при каждом вызове кода с тем же (долгосрочным) маркером CancellationToken он будет добавлять новый обратный вызов (который, в свою очередь, будет поддерживать существование объекта Ping). Чтобы избежать утечки памяти и ресурсов, очищайте регистрацию обратного вызова, когда он перестаёт быть нужным.

Источник: Стивен Клири “Конкурентность в C#”. 2-е межд. изд. — СПб.: Питер, 2020. Глава 10.

День 1312. #CodeReview
Насколько Хорош Ваш Процесс Код-Ревью?
Если ваша команда считает код-ревью пустой тратой времени, то они правы. Те, кто не ценит проверки кода, откладывают их выполнение, часто мало чего находят, либо их комментарии носят чисто стилистический характер. В такой команде внедрение код-ревью может только ухудшить процесс разработки, замедлив его без улучшения качества кода.
Можно построить процесс проверки кода, который будет повышать эффективность, но нужно действовать целенаправленно. Во-первых, организация должна договориться о целях. Во-вторых, нужно регулярно отслеживать показатели проверки, чтобы убедиться, что цели достигнуты и процесс работает исправно.

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

Ключевые показатели
Метрики могут быть разными в зависимости от целей, но есть несколько общих, которые позволят быстро диагностировать и устранять проблемы, связанные с процессом проверки.

1. Скорость
«Время до первого отзыва» — среднее время ожидания отзыва отправителем. Когда этот показатель высок, отправители либо тратят время на ожидание, либо вынуждены делать что-то другое. Если это происходит, важно согласовать ожидания от проверки кода и то, как проверки могут быть лучше интегрированы в повседневные процессы. Определите, что для вас означает «низкое» время до первого отзыва. Относительно этого можно углубляться в индивидуальные и командные показатели: размер пул-реквестов, баланс рабочей нагрузки и скорость проверки. Важно снизить время до первого отзыва настолько, насколько это возможно, без ущерба для внимания и производительности рецензентов.

2. Покрытие
Если ваша цель — улучшить качество кода и выявить ошибки, важно сравнить количество файлов с комментариями в обзоре с количеством изменённых файлов в пул-реквесте. Это будет показателем тщательности проверки. Не существует оптимального числа, но вы должны убедиться, что результат соответствует ожиданиям. Чтобы рецензенты не просто проштамповывали любые изменения, но, и чтобы не сильно придирались и не замедляли процесс.

3. Влияние
Одно только покрытие отзывами не говорит о качестве кода. Важно посмотреть, все ли эти отзывы приводят к действиям? Для этого отслеживайте процент комментариев, которые приводят к ответным комментариям или изменениям в коде. Большое количество комментариев с низким «влиянием» указывает на то, что отзывы рецензентов не воспринимаются как ценные для отправителя. Это может потребовать перестройки того, как должны проводиться проверки кода.

4. Циклы
Пулл-реквесты, перескакивающие туда-сюда между автором и рецензентом, могут замедлять процесс. Если это происходит часто, процесс рецензирования может стать узким местом и источником демотивации для инженеров, пытающихся завершить свою работу.
Средний показатель может меняться по многим причинам. Привлечение новых разработчиков может вызвать всплеск. Однако такой всплеск в опытной команде часто является признаком рассогласованности представлений:
- о том, что значит «готово»,
- какие изменения ожидаются после комментария,
- как должно быть реализовано решение.
Если количество циклов проверки для определённого отправителя велико, это может означать, что он не понимает кодовую базу или имеет дело с нечёткими требованиями.

Проверка кода — один из самых сложных процессов в команде разработчиков ПО. В каждой команде существует свой идеальный баланс тщательности и скорости, и этот баланс может даже измениться для данной команды из-за изменения приоритетов. Менеджеры должны постоянно следить за процессом код-ревью, беседовать с командой, чтобы собрать информацию, необходимую для придания контекста метрикам проверки кода и придания им значимости.

Источник: https://thenewstack.io/how-good-is-your-code-review-process/

День 1313. #TypesAndLanguages
Ваш Язык Влияет на то, Как Вы Думаете. Начало
Кажется очевидным, не так ли? Ваш язык диктует правила, и вам нужно играть по правилам. Однако последствия гораздо серьёзнее, чем вы думаете. Дело не только в том, что мы выбираем решения, которые просты в использовании на данном языке. Также мы считаем некоторые решения «плохими в целом», потому что они могут создавать некоторые проблемы на данном языке. Однако мы должны помнить, что концепции никогда не бывают хорошими или плохими. Именно то, как мы их используем, делает их таковыми.

Контейнеры внедрения зависимостей
Java-программисты часто заявляют, что DI-контейнеры — это плохо, и мы не должны их использовать. Вы можете найти сообщения в блогах, доклады на конференциях или дискуссии о том, почему мы не должны использовать DI и почему следует отказаться от Spring. В то же время Microsoft поддерживает DI-контейнер непосредственно в платформе .NET Core. Как так?

Дело не в том, что DI-контейнеры хороши или плохи. Дело в том, как мы их используем. Все методы экземпляра в Java являются виртуальными. Это делает переопределение очень простым и возможным почти всегда. Это привело к массовому использованию cglib для создания динамических прокси во время выполнения. Контейнеры DI в Java позволяют внедрять transient объекты в синглтоны — что является плохой практикой и отслеживается в .NET. То же самое касается серверов приложений — они гораздо популярнее и мощнее в мире Java, чем в .NET.

Поскольку проще использовать генерацию кода, проще делать более мощные и более опасные решения. А это приводит к проблемам: чтобы использовать мощные решения, нужно их понимать и уметь не навредить себе. А поскольку у нас не так много времени на изучение наших инструментов, мы часто вносим неправильные изменения в нашу кодовую базу. Это приводит к тонким проблемам с транзакциями, потерей данных и т.п. Java-программисты заметили это и решили не использовать эти возможности. Однако дело не в том, что «контейнеры DI плохи». Это «то, как мы используем DI-контейнеры в мире Java, слишком опасно и приводит к множеству проблем». Просто изучите свои инструменты, и вы будете в большей безопасности.

Частичные моки и виртуальные методы
То же самое происходит и в тестах. Java позволяет переопределить почти любой метод экземпляра, поэтому создание частичного мока разрешено и поддерживается по умолчанию. С другой стороны, вам нужно явно пометить свой метод виртуальным в C#, поэтому обычно вы этого не делаете. Если вы это сделаете, люди могут начать задавать вопросы в код-ревью вроде «почему он виртуальный? вы переопределяете его?». Таким образом, вы не делаете его виртуальным и не можете использовать частичные моки. Совершенно иначе, чем в Java.

Поскольку это разрешено в Java, оно используется чаще. Причина в том, что «если это разрешено по умолчанию, то это должно быть хорошо». Опять же, не стоит обобщать.

Множественное наследование
C++ допускал множественное наследование, и люди испугались проблемы алмаза. Java и C# решили полностью избежать этой проблемы, поэтому они множественное наследование запретили. Однако в то же время они заблокировали множественное наследование состояний и множественное наследование реализации. Единственной разрешённой формой было множественное наследование интерфейсов. К сожалению, проблема алмаза реально существует в языках C# и Java с самого начала.

Поэтому люди испугались наследования. В то же время такие языки, как Scala, допускают почти полное множественное наследование, и это не проблема. Даже Java и C# представили реализацию интерфейса по умолчанию, которую можно использовать для реализации миксинов и множественного наследования состояний. А что, теперь стало можно? Опять же, нельзя сказать, что множественное наследование хорошо или плохо само по себе. Проблема в том, как мы его используем.

Окончание следует…

Источник: https://blog.adamfurmanek.pl/2022/07/23/types-and-programming-languages-part-16/
Автор оригинала: Adam Furmanek

День 1314. #TypesAndLanguages
Ваш Язык Влияет на то, Как Вы Думаете. Окончание
Начало

Наследование против композиции
Что из этого мы должны использовать? «Очевидно — композицию. Наследование — это плохо». Опять же, легко обобщать, но это не обязательно правильно.

Возможности ООП активно использовались на заре Java. Наследование было прорывом, глубокая классовая иерархия не удивляла. Как ни странно, божественные объекты также были популярны. Прошло время, и люди поняли, что помещать всё в класс длиной 8000 строк — не лучшая идея. Так что нам делать? «Запретить наследование, использовать композицию».

На самом деле дискуссия уходит гораздо глубже. Должны ли мы использовать сценарий транзакции и анемичную модель предметной области? Это хорошо? Или нам следует использовать классы с сохранением состояния и предметно-ориентированное проектирование?

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

Goto
Конечно, вы не можете использовать goto. Его надо запретить и убрать из языка. Теперь зайдите на GitHub и посмотрите варианты использования. Вы удивитесь.

Преждевременная оптимизация
Этим сильно злоупотребляют. Полная цитата гласит: «Мы должны забыть о неэффективности примерно в 97% случаев: преждевременная оптимизация — корень всех зол». Однако это относится к микрооптимизациям, таким как i++ против ++i. И да, такая оптимизация, вероятно, не нужна, так как наш код работает медленно из-за других вещей.

В то же время не следует пренебрегать фактором оптимизации. Думайте об алгоритме, а не о циклах под капотом. Удалите ненужные коллекции и структуры данных, но не забивайте голову работой по выравниванию битов.

Однако очень легко снизить производительность, используя возможности языка. Отличным примером является LINQ в .NET — первое, что вы делаете для ускорения работы, — это избавляетесь от LINQ. Хотя по умолчанию он доступен.

Зелёные потоки
Зелёные потоки (если коротко, это потоки, управляемые средой выполнения, а не операционной системой) были популярны, но в какой-то момент подверглись жёсткой критике. В Microsoft написали об этом хорошую статью. C# представил асинхронность, которая позже была скопирована в другие языки (Python, JS, C++, Kotlin).

Однако Java реализовала асинхронность по-другому в своем проекте Loom. Они использовали виртуальные потоки под капотом. И тут в Microsoft внезапно решили поэкспериментировать с зелёными потоками в .NET.

Забавно, правда? Опять же, дело не в том, что концепция плоха. Дело в том, как мы это используем. Зелёные потоки также создают проблемы, особенно в отношении блокирующих операций, примитивов блокировки или interop-вызовов. Но это опять же о реализации, а не об идее.

Источник: https://blog.adamfurmanek.pl/2022/08/13/types-and-programming-languages-part-18/

День 1315. #ЧтоНовенького
Bulk-Операции в Entity Framework 7
В EF наконец завезут Bulk-Update и Bulk-Delete. Добавленные методы улучшают производительность. Теперь мы можем делать обновления и удаления с помощью всего одной операции, результатом которой будет одна команда SQL.

Рассмотрим использование этих операций. Допустим, у нас есть класс людей:

public class Person
{
  public long Id { get; set; }
  public string Name { get; set; }
  public int Age { get; set; }
}

ExecuteDelete
Чтобы массово удалить набор сущностей, отфильтруем их с помощью Where (как раньше), а затем вызовем ExecuteDelete. Помимо прочего, метод возвращает количество удалённых записей:

var personsDeleted = context.Persons
  .Where(p => p.Name.Contains("L"))
  .ExecuteDelete();

Вот какой код SQL он сгенерирует:

DELETE FROM [p]
FROM [Persons] AS [p]
WHERE [p].[Name] LIKE N'%L%'

Как видите, он просто генерирует одну инструкцию SQL для удаления сущностей, соответствующих условию.

ExecuteUpdate
Для обновления сущностей нам нужно использовать новый метод SetProperty. Первый аргумент SetProperty выбирает свойство, которое необходимо обновить с помощью лямбда-выражения, а второй аргумент — это новое значение этого свойства также с помощью лямбда-выражения, в котором мы также можем получать доступ к свойству. Например, здесь мы добавим префикс "New" к имени первой тысячи людей:

var personsUpdated =
  context.Persons
    .Where(p => p.PersonId <= 1_000)
    .ExecuteUpdate(
      p => p.SetProperty(
        x => x.Name,
        x => "New" + x.Name)
    );
}

В результате возвращается количество обновлённых записей, а SQL код получается таким:

UPDATE [p]
 SET [p].[Name] = N'New' + [p].[Name]
FROM [Persons] AS [p]
WHERE [p].[Id] <= CAST(1000 AS bigint)

Чтобы обновить несколько свойств за раз, просто вызовите методы SetProperty в цепочке:

….ExecuteUpdate(p =>
   p.SetProperty(x => x.Name, x => "…")
    .SetProperty(x => x.Age, x => 42)
  );
}

Источник: https://timdeschryver.dev/blog/new-in-entity-framework-7-bulk-operations-with-executedelete-and-executeupdate

День 1316. #ЗаметкиНаПолях
Неочевидные Различия в Regex
1. \d или [0-9]
В документации .NET про Regex, \d означает любую цифру. Что означает термин «цифра», зависит от опций выражения:
- по умолчанию, без опции RegexOptions.ECMAScript, \d означает \p{Nd}, т.е. любой символ из категории «цифр» в Unicode;
- с опцией RegexOptions.ECMAScript \d означает [0-9].

Категория цифр в Unicode содержит цифры 0, 1, 2, … но также цифры из других языков, вроде ٣, ٧, ൩ или ໓. Полный список состоит из 610 символов!
Поэтому

Regex.IsMatch("०१२३४५६७८९", "[0-9]{10}"); 

вернёт False, тогда как

Regex.IsMatch("०१२३४५६७८९", "\\d{10}");

вернёт True.

Добавление опции решает проблему:

Regex.IsMatch("०१२३४५६७८९", "\\d{10}", RegexOptions.ECMAScript);

вернёт False.

2. [a-zA-Z] или [a-z] с IgnoreCase
Рассмотрим два регулярных выражения:

var regex1 = new Regex("^[a-zA-Z]+$");
var regex2 = new Regex("^[a-z]+$", 
  RegexOptions.IgnoreCase | 
  RegexOptions.CultureInvariant);

В большинстве случаев они работают одинаково, так, как мы и предполагаем:

regex1.IsMatch("Test"); // True
regex2.IsMatch("Test"); // True

Однако, есть специальный символ K (U+212A), обозначающий температуру по Кельвину, и здесь всё интереснее:

regex1.IsMatch("K"); // False
regex2.IsMatch("K"); // True

Когда в регулярном выражении указан параметр RegexOptions.IgnoreCase, сравнение между входными данными и шаблоном будет выполняться без учёта регистра. Чтобы поддерживать это, Regex необходимо определить, какие отображения регистра будут использоваться для сравнений. Отображение регистра существует всякий раз, когда у вас есть два символа «A» и «B», где либо:
- «A» является ToLower() представлением «B»,
- оба символа являются представлением в нижнем регистре для одного и того же символа.

В этом случае char.ToLowerInvariant('K') - это k (строчная латинская буква K). Поэтому второе выражение возвращает True для знака Кельвина, однако он не входит в множество [a-zA-Z], поэтому первое выражение возвращает False.

Источник: https://www.meziantou.net/regex-with-ignorecase-option-may-match-more-characters-than-expected.htm

День 1317. #ЗаметкиНаПолях #ЧтоНовенького
Исправляем Предупреждение CS891
Если вы были одним из первых пользователей .NET 7, возможно, вы столкнулись со следующей ошибкой при компиляции существующего проекта .NET 6:
Warning CS8981: The type name only contains lower-cased ascii characters. Such names may become reserved for the language. (Имя типа содержит символы только в нижнем регистре. Такие имена могут быть зарезервированы под ключевые слова языка.)

Хотя предупреждение в принципе довольно подробное, в нём отсутствует пояснение, почему оно отображается. Особенно когда в .NET 6 код компилировался успешно. Рассмотрим на очень простой пример того, почему это предупреждение было добавлено.

Представим, что мы вернулись на много лет назад и пишем код C# в .NET 2.0. У нас есть код, который выглядит так:

class async {
}

В то время async/await не существовало в .NET, и вы могли бы создать класс, названный с использованием любого из этих ключевых слов, даже если они не соответствовали традиционным стандартам именования PascalCase.

Тут мы решаем обновиться до C# 5, а вместе с ним к нам пришли ключевые слова async/await. Теперь у нас проблемы, потому наш класс имеет конфликт имён.

Microsoft активно выпускает ежегодные выпуски .NET/C#, и само собой разумеется, что они могут добавить дополнительные зарезервированные ключевые слова в язык. Но до этого времени Microsoft, очевидно, не может зарезервировать все возможные комбинации ключевых слов, которые могут понадобиться в будущем.

Поэтому в Microsoft явно указали на тот факт, что все зарезервированные ключевые слова пишутся полностью строчными буквами. И, если вы следуете соглашениям об именовании, которые советуют не называть всё исключительно строчными буквами, то вы можете быть уверены, что в будущем у вас не будет конфликтов.

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

Источник: https://dotnetcoretutorials.com/2022/08/10/fixing-cs891-the-type-name-only-contains-lower-cased-ascii-characters/

День 1318. #DevOps
6 Принципов Разработки Архитектуры ПО
В последнее время термин «непрерывный» (continuous) очень часто используется в речи поставщиков ПО и экспертов как программная архитектура, которую мы все должны и хотим иметь. Проблема в том, что многие считают, что «непрерывный» означает быструю доставку. Однако проектирование непрерывной программной архитектуры требует постоянной обратной связи от всех участников процесса: архитекторов, дизайнеров, разработчиков, операторов — и постоянного улучшения. Разработка архитектуры ПО больше не может быть разовым процессом.

Об этом на недавней конференции GOTO 2022 поговорили Пьер Пюрер, соавтор книги «Continuous Architecture in Practice», и Курт Биттнер, глава отдела корпоративных решений в Scrum.org.

«Проектирование и поддержка хорошо функционирующей непрерывной программной архитектуры требует, прежде всего, терпения,» - считает Пюрер. - «Cпешить с технологическим решением, прежде чем задать правильные вопросы, означает упускать возможности или функции, которые могут быть жизненно важными для бизнеса. Я видел команды, которые начинают с конца, и они знают, что хотят внедрить какую-то технологию. Кто-то сказал им: «Нам нужно быть в облаке Amazon». Ответом будет облако Amazon, а вы даже не задаёте этот вопрос.»

В течение многих лет проектирование архитектуры ПО означало проектирование чего-либо на начальном этапе, а затем переход к этапу развёртывания. Согласно традиционному представлению об архитектуре, «мы не пишем ни строчки кода, пока вся архитектура не будет собрана», — сказал Пюрер.

«Проблема с таким подходом, конечно, в том, что очень сложно знать всё сразу. Проектирование архитектуры, когда более половины ваших требований неверны, не даст вам хороших результатов. Трудно предсказать, как система будет эволюционировать."

Появились более гибкие подходы, что сделало процесс более итеративным. Тем не менее, это предполагает, что «вы пишете код, и архитектура каким-то образом появляется, как кит из воды». Но это приводит к необходимости «большого рефакторинга и перенастройки».

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

Им нужно задавать трудные вопросы: что нужно бизнесу? Что лучше сработает для пользователей или клиентов? Какие части бизнеса должны быть вовлечены в процесс проектирования?

По словам Пюрера, в основе успешной непрерывной архитектуры лежат шесть принципов. «Ни один из принципов не является новым или революционным, но вместе они имеют большой смысл».

Вот эти принципы:
1. Создавайте архитектуру продукта, а не проекта. Звучит очевидно, но многие об этом забывают.
2. Сосредоточьтесь на атрибутах качества, а не на обширности функционала. Да, функциональные требования важны, но, если качество не соответствует, у вас не получится эффективного продукта.
3. Откладывайте решения до тех пор, пока не будете уверены, что должны принять решение. У каждого решения есть цена. А если оно окажется неверным, будет и цена отката этого решения. Не принимайте решения слишком рано, пытаясь угадать, старайтесь основывать решение на фактах.
4. Планируйте изменения, потому что всё изменится — так что подумайте о «минималистичном дизайне». Хотя это не обязательно означает микросервисы.
5. Помните, тестирование сборки системы важно, но тестирование развёртывания системы едва ли не важнее.
6. Организуйте команду из людей, которые занимаются всеми аспектами системы. Да, может быть разделение на фронт и бэк, но все специалисты должны чётко представлять, какой продукт должен получиться.

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

Источник: https://www.zdnet.com/article/agile-alertness-6-principles-to-help-your-software-design-process-succeed/

День 1320. #ЗаметкиНаПолях #AsyncTips
Асинхронные интерфейсы и наследование

Задача: В интерфейсе или базовом классе имеется метод, который требуется сделать асинхронным.

Решение
Ключом к пониманию этой задачи и её решения станет понимание того, что async относится к подробностям реализации. Ключевое слово async может применяться только к методам с реализациями. Невозможно применить его к абстрактным методам или методам интерфейсов (если они не имеют реализации по умолчанию). Тем не менее вы можете определить метод с такой же сигнатурой, как у async-метода, но без ключевого слова async.

Ожидание допускают типы, а не методы. Вы можете использовать await с объектом Task, возвращённым методом, независимо от того, был метод реализован с ключевым словом async или нет. Таким образом, интерфейс или абстрактный метод может просто вернуть Task (или Task<T>), и это значение может ожидаться.

Следующий пример определяет интерфейс с асинхронным методом (без ключевого слова async), реализацию этого интерфейса (с async), и независимый метод, который потребляет метод этого интерфейса (посредством await):

interface ICountBytes
{
  Task<int> CountBytesAsync(
   HttpClient hc, string url);
}

class Counter : ICountBytes
{
  public async Task<int>
   CountBytesAsync(HttpClient hc, string url)
  {
    var b = await hc.GetByteArrayAsync(url);
    return b.Length;
  }
}

…

async Task UseCounter(
  HttpClient hc,
  ICountBytes svc)
{
  var res = await svc.CountBytesAsync(
   hc,
   "https://www.google.com");
  
  Console.WriteLine(res);
}

Этот паттерн работает и с абстрактными методами базовых классов.
Асинхронная сигнатура метода (возврат Task или Task<T>) означает лишь то, что реализация может быть асинхронной. Фактическая реализация может быть синхронной, если нет реальной асинхронной работы, которую нужно было бы выполнять. Например, тестовая заглушка может реализовать тот же интерфейс (без async), используя, например, FromResult:

class CounterStub : ICountBytes
{
  public Task<int> CountBytesAsync(
   HttpClient hc, string url)
  {
    return Task.FromResult(13);
  }
}

Асинхронные методы интерфейсов и базовых классов встречаются всё чаще. Работать с ними не так уж сложно, если помнить, что ожидание должно применяться к возвращаемому типу (а не к методу), а определение асинхронного метода может быть реализовано как асинхронно, так и синхронно.

См. также: Возвращение завершённых задач

Источник: Стивен Клири “Конкурентность в C#”. 2-е межд. изд. — СПб.: Питер, 2020. Глава 11.

День 1321. #ЗаметкиНаПолях
Получаем Согласие Пользователя Перед Выполнением Конфиденциального Кода
Перед выполнением конфиденциальных действий, таких как покупка чего-либо или показ конфиденциальных данных, необходимо получить согласие пользователя. Кроме того, необходимо убедиться, что фактический пользователь является тем, кто выполняет действие. Windows предоставляет API для получения согласия пользователя перед выполнением конфиденциальных действий.

Во-первых, нужно указать, что проект нацелен на Windows, установив свойство TargetFramework в файле .csproj:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0-windows10.0.17763.0</TargetFramework>
  </PropertyGroup>
</Project>

Теперь вы можете использовать специфический API для Windows, чтобы получить согласие:

using Windows.Security.Credentials.UI;
async Task<bool> ConsentAsync(string reason)
{
  var availability = await
   UserConsentVerifier.CheckAvailabilityAsync();
  
  if (availability ==
    UserConsentVerifierAvailability.Available)
  {
    var result = await
     UserConsentVerifier
      .RequestVerificationAsync(reason);
    
    return result ==
     UserConsentVerificationResult.Verified;
  }

  return false;
}

Также можно использовать метод ConsentAsync перед выполнением действия:

if (await ConsentAsync("Confirm your identity"))
  Console.WriteLine("Cofirmed");
else
  Console.WriteLine("Not confirmed");

Источник: https://www.meziantou.net/getting-user-consent-before-executing-sensitive-code.htm

День 1322. #ЧтоНовенького
Cборки в .NET 7 Обрезаются по Умолчанию
Все сборки в консольных приложениях в .NET 7 теперь обрезаются (trimmed) по умолчанию. Это изменение влияет только на приложения, опубликованные с параметром PublishTrimmed=true, и нарушит работу только тех приложений, для которых ранее выдавались предупреждения при тримминге. Это также влияет только на простые приложения .NET, которые не используют Windows Desktop, Android, iOS, WASM или ASP.NET SDK.

Ранее обрезались только сборки с параметром <IsTrimmable>true</IsTrimmable> в файле проекта библиотеки.

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

Если в вашем приложении были предупреждения о тримминге, вы можете увидеть изменения в поведении или исключения. Например, приложение, использующее Newtonsoft.Json или System.Text.Json без генерации исходного кода для сериализации и десериализации типов в пользовательском проекте, могло функционировать до изменения, поскольку типы в проекте полностью сохранялись. Выдавалось лишь одно или несколько предупреждений о тримминге (коды предупреждений ILxxxx). Теперь типы в пользовательском проекте обрезаются, и сериализация может завершиться ошибкой или привести к непредвиденным результатам.

Причина изменения
Это изменение помогает уменьшить размер приложения без явного согласия пользователей и соответствует ожиданиям пользователей, что всё приложение будет обрезаться, если не указано иное.

Рекомендованное действие
Лучшее решение — устранить все предупреждения о тримминге. Сведения об устранении предупреждений в ваших библиотеках можно посмотреть в разделе документации «Общие сведения о предупреждениях об обрезке».

В отношении сторонних библиотек, обратитесь к автору, чтобы попросить устранить предупреждения, или выберите другую библиотеку, которая уже поддерживает тримминг. Например, вместо Newtonsoft.Json можно переключиться на System.Text.Json с генерацией исходного кода.

Чтобы вернуться к предыдущему поведению, задайте для свойства TrimMode значение partial, которое было поведением по умолчанию до .NET 7:

<TrimMode>partial</TrimMode>

Поведение по умолчанию в .NET 7+:

<TrimMode>full</TrimMode>

Источник: https://docs.microsoft.com/en-us/dotnet/core/compatibility/deployment/7.0/trim-all-assemblies

День 1323. #Книги
По совету из здешнего чата прочитал книгу «Мой продуктивный год» (Крис Бэйли — М.: Альпина Паблишер, 2022).

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

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

Читается на одном дыхании и очень мотивирует. Некоторые из практик пробую применять.

День 1324. #ЗаметкиНаПолях
Как Получить Базовый URL в ASP.NET Core
Обычно это не нужно. По крайней мере, не из кода самого приложения. Однако существует ряд причин, по которым это всё ещё может быть актуально, например, если вы хотите сгенерировать и вывести абсолютный URL-адрес в контроллере MVC или на странице Razor.

Допустим, у нас есть адрес страницы:
https://example.com/path/document/?id=42

URL состоит из схемы (https), имени хоста (example.com), пути (path/document/), и строки запроса (id=42). Базовый адрес представляет собой комбинацию схемы, порта и имени хоста:
https://example.com
Номер порта можно не указывать, если веб-сервер прослушивает порт 443 для HTTPS или порт 80 для HTTP-запросов.

Насколько мне известно, в ASP.NET Core нет встроенных способов получить базовый URL, но запрос предоставляет достаточно информации, чтобы собрать его вручную:

public IActionResult Index()
{
  var base = $"{Request.Scheme}://{Request.Host}:{Request.Host.Port ?? 80}";
  return View();
}

Этот пример обычно предлагается на StackOverflow. Есть некоторые недостатки в использовании такой интерполяции строк. Очевидным является часть порта, которую мы в большинстве случаев не хотим включать. К счастью, в .NET есть встроенный класс для создания URL-адресов с именем UriBuilder. Немного отрефакторим код и включим его в метод расширения HttpRequest:

public static class HttpRequestExtensions
{
  public static string? BaseUrl(
   this HttpRequest req)
  {
    if (req == null) return null;
    var uriBuilder = new UriBuilder(
     req.Scheme, 
     req.Host.Host,
     req.Host.Port ?? -1);
    
    if (uriBuilder.Uri.IsDefaultPort)
      uriBuilder.Port = -1;
       
    return uriBuilder.Uri.AbsoluteUri;
  }
}

В этом примере мы используем класс UriBuilder для добавления схемы и имени хоста, а порт добавляем только в том случае, если он есть в запросе. Значение -1 (как ни странно) не указывает на отсутствие порта в UriBuilder. Оператор if позволяет избежать отображения номера порта в базовом URL, используется порт по умолчанию для схемы. Т.е., если схема https и порт 443, нам просто нужен https://example.com, а не https://example.com:443.

Теперь для получения базового URL-адреса требуется всего одна строка:

Request.BaseUrl();

В Razor Pages у нас не будет доступа к HTTP-запросу, как в MVC. Здесь требуется внедрить HttpContextAccessor в файл Program.cs (Startup.cs):

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpContextAccessor();
// ...
var app = builder.Build();
// ...

После этого можно внедрить IHttpContextAccessor на страницу Razor:

{
  private readonly IHttpContextAccessor hCA;
  public IndexModel(IHttpContextAccessor hCA)
  {
    this.hCA = hCA;
  }

  public void OnGet()
  {
    var baseUrl = 
     hCA.HttpContext?.Request.BaseUrl();
    // ...
  }
}

Источник: https://blog.elmah.io/how-to-get-base-url-in-asp-net-core/

День 1325. #Оффтоп
Открытый Код и Случайные Инновации
Чем более открыта система для новых контрибуторов, тем больше шансов, что случайная встреча принесёт пользу всем участникам.

В конце 1970-х годов в разработке технологий доминировала горстка крупных компаний из Бостона, которые всё финансировали и привлекали в основном талантливых инженеров из Массачусетского технологического института.

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

Сейчас, когда мы живем в 2020-х годах, произошло ещё одно важное событие, стимулирующее инновации, — это ПО с открытым исходным кодом. По мере того, как открытый код становился всё более популярным в 21 веке, темпы развития отрасли стремительно росли. В частности, это было обусловлено фреймворками ПО с открытым кодом, такими как LAMP или .NET Core, средами разработки и инновациями в базах данных, развитием CMS, поиска и других основных вычислительных функций. Разработка продвинулась «вверх по стеку», так что новым приложениям не нужно изобретать велосипед.

Это также привело к резкому росту экономической активности. Доступность децентрализованных инструментов разработки, таких как GIT, также экспоненциально расширила возможности технических работников по созданию неформальных сетей и совместной работе по всему миру. Не случайно в 2000-е почти все компании стали производителями ПО — от финансов до здравоохранения и образования. ПО управляет нашим миром, и ПО с открытым кодом является правилом, а не исключением в разработке.

Многие попадают в разработку ПО почти случайно. Услышав о программировании от знакомых, попробовав что-то написать самостоятельно или по статье или видеоуроку в сети. Эти случайности могли произойти только потому, что люди делятся своими знаниями, в основном неструктурированным образом. Этот неформальный обмен, который теперь может выходить за пределы географических, политических и бизнес-блоков, — вот что заставляет мир изобретать. Теперь мы наблюдаем ещё один сдвиг — к постгеографическому миру разработки программного обеспечения, великому «перераспределению» возможностей между городами и поселками, далекими от традиционных технологических центров.

Что читатель должен извлечь из этого поста? Что карьера зависит не только от случайности, но и от страстного намерения? Что местоположение может быть судьбоносным, но нельзя предсказать, где произойдет следующий прорыв?

Самый важный урок о случайных инновациях заключается в том, что они не являются транзакционными. На протяжении многих лет бизнес воспринимал использование открытого исходного кода как глупость, пустую трату времени и знаний, и как предоставление услуги бесплатно. Это потому, что они думали в стиле Бостонских компаний 1970-х, а не в стиле Кремниевой долины.

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

Источник: https://stackoverflow.blog/2022/08/24/open-source-and-accidental-innovation/