Обновить
8K+
42
Nikita P.@grub_loader

Системный инженер

Отправить сообщение

Про Го - очень и очень спорно. Версия на Го заметно хуже оптимизирована. Например, Node почти вдвое тяжелее, после разбора весь массив узлов копируется и очищается, поиск <, = и > сделан простым побайтовым циклом, тогда как в том же Раст и C# используются специализированные процедуры. Замеры не честные

Safari, MacOS 27, полет ок=)

От одного вида уже ностальгия накатила, спасибо! Пойду тестить

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

А с чего Вы решили, что эксплуатация уязвимости обязана быть универсальной? CVE описывает конкретную ошибку и условия её эксплуатации, а не какой-то гарантированный способ взломать любую систему. Для sshhole уже есть публичные reproducer'ы, а PHP2Shell вообще эксплуатируется в реальных атаках. Вы не смогли найти рабочий пример или даже разобраться в условиях эксплуатации, но на этом основании решили поставить под сомнение сами уязвимости? С таким подходом может ещё и переполнение буфера будете отрицать, если эксплойт не сработал на вашем компьютере?)

Вы опять путаете достаточность ресурсов с эффективностью их использования. То, что вам сегодня хватает 16 ГБ не означает, что завтра их будет достаточно. При таком подходе разработчиков растут не только возможности приложений, но и их аппетиты к ресурсам, зачастую без соразмерного увеличения функциональности. Любую неэффективность можно оправдать наличием свободной памяти, пока однажды она не закончится. И вместо того чтобы писать нормальный код, снова предложат обмазаться железом. И про закон Мура, видимо, стоит пояснить. Он описывает историческую тенденцию роста числа транзисторов на микросхемах, и не гарантирует бесконечный рост производительности и доступных ресурсов. У полупроводниковых технологий есть физические и экономические ограничения. Десятилетиями рост возможностей железа позволял маскировать неэффективность софта, это просто факт. Только вот рассчитывать, что процессоры и память будут бесконечно компенсировать глупые инженерные решения, - довольно сомнительная стратегия. И мы сейчас как раз находимся в том самом времени, когда закон Мура начинает выстреливать

Функция с exception не заставляет писать try/catch в месте вызова. Если здесь ошибку обрабатывать нечем - не ловишь её вообще, она уходит выше по стеку. Пустой catch - баг, он просто проглатывает ошибку. И с optional/expected как раз больше ручной работы, их надо явно протаскивать через каждый промежуточный уровень. Exception же это делает автоматически. Аргумент про "в try непонятно, откуда прилетело" это проблема слишком широкого try, а не механизма исключений

Приветствую, коллега! Я с основной мыслью (не использовать исключения как штатный control flow) в данном конкретном примере скорее согласен. Но позволю кое-где поспорить. __cxa_throw не делает longjmp. В обычной Itanium/DWARF-модели он запускает UnwindRaiseException, SJLJ вообще отдельная модель обработки исключений. Двухфазный поиск и unwind действительно есть, но описывать это как длинный longjump в целом некорректно. .eh_frame тоже не содержит какой-то список созданных объектов, которым надо вызвать деструкторы. Там unwind/CFI-информация в первую очередь. Cleanup выполняется с помощью сгенерированных компилятором landing pads и EH-таблиц. И главный момент - table-based exceptions называются zero-cost не просто так. Если исключение не бросается, нормальный путь обычно практически не платит за try/catch, дорогой тут именно фактический throw, потому рассуждение о производительности без частоты ошибок и бенчмарка не доказывает ничего. Из мелочей - std::optional это не разновидность умного указателя. Значение хранится внутри самого optional, причём предложенная в статье замена в показанном виде даже не скомпилится - вызывается старый VariantToStringVisitor, а затем std::optional<std::string> присваивается непосредственно в std::string.

Ну, то есть, если неподходящий тип конфигурации - это ожидаемый результат парсинга, я бы тоже вернул optional или expected, но из этого не следует, что исключения вообще хуже или что try/catch сам по себе создаёт существенные накладные расходы

Поверхность атаки безумная

Я не думаю, что в этом плане в настоящее время ИИ сделает хуже, чем те, кто написали это приложение. Уже то, сколько приложение жрет ОЗУ (и не только его) говорит о том, как там относятся к эффективному кодингу и оптимизациям

многие компании клали с препаратом на оптимизации

Вот именно их закон Мура и поимеет =)

Ну вот всем достаточно (якобы), а ведь дело не в том, сколько приложений можно запустить, а в том, сколько ресурсов они жрут для выполнения элементарных задач. Десятилетиями неэффективный код компенсировали наращиванием железа. Только закон Мура не гарантирует бесконечного роста, а физические пределы никто никогда не отменял. В итоге вместо оптимизации научились просто просить... Нет, - требовать больше памяти

Довольно печально, что такие оптимизации делаются "из-за кризиса памяти", а не ради просто улучшения/оптимизации работы приложения

Я думаю, что они пока даже не понимают до конца, что именно нужно искать, потому смотрят вручную, выявляя какие-то закономерности. То есть, пока не до конца поняли, как именно всё произошло от и до. Но это моё мнение, как уж там на самом деле - не знаю

Нашел у них на канале очень ироничную новость 2024 года.

Скрытый текст

Всем привет! Мы обновили SLA (соглашение об уровне сервиса) для облачных услуг. В соответствии с новым SLA мы гарантируем 99,98% бесперебойности работы для:

  • виртуальных серверов (VPS);

  • облачных баз данных (DBaaS);

  • объектного хранилища S3 и других наших облачных сервисов.

Теперь немного подробнее 😊 Договор SLA (Service Level Agreement) – это документ, который определяет стандарты качества предоставляемых услуг, условия их оказания, а также права и обязанности сторон. Такое соглашение обеспечивает прозрачность, позволяет установить ожидания и отследить выполнение обязательств – и в данном случае, касательно облачных сервисов, речь идет об их доступности. Данный показатель рассчитывается так: берется время работы в течение определенного промежутка (например, месяца или года), разбивается на пятиминутные интервалы, а затем из 100% таких интервалов в течение определенного срока (например, месяца или года) вычитается время, когда услуга была полностью недоступна. Мы знаем, что доступность – ключевой показатель для владельца любого проекта, и поэтому доступность облачных услуг Бегета гарантируется на уровне не менее 99,98% – таким образом, в месяц суммарный простой наших сервисов не превышает 8 минут и 46 секунд. Этот показатель распространяется на наши сервисы и продукты во всех локациях – напомним, на данный момент это Россия, Казахстан и Латвия. Мы понимаем, что любому проекту важна надежность, и делаем всё, чтобы вы могли спать спокойно 😊 Ознакомиться с соглашением об уровне предоставления облачных услуг вы можете здесь. С удовольствием ответим в комментариях на любые ваши вопросы 😉

Забавно, что в статье про data race и undefined behavior один из примеров сам содержит UB :) В calculate() результат суммы от 1 до 1 000 000 хранится в int. Правильная сумма там 500000500000, что сильно больше INT_MAX. В итоге происходит signed integer overflow, а в C++ это undefined behavior. То есть пример со std::async формально уже некорректен независимо от многопоточности. Достаточно заменить result на std::int64_t или long long

Проект в целом выглядит здраво! Есть парочка моментов относительно спорных. Например, про отказ от regexp. Regexp в Го тоже гарантирует линейное время, так что без бенчмарков спорно. С multipart/form-data поддержка тоже пока не совсем полная, в OpenAPI 3.1 есть Encoding Object для отдельных частей multipart, а его, насколько понял, пока нет (может, ошибаюсь). Golden-check полезен как защита от регрессий в целом, но он проверяет только неизменность вывода генератора, а не соответствие OpenAPI 3.1. Я бы таки добавил независимый валидатор спецификации в CI. А, и ещё момент - Го-структуры становятся source of truth для моделей, но Route, Success, content type и прочее всё равно живут в комментариях и могут разъехаться с реальным поведением API. В остальном направление правда здравое

Я, если честно, не очень понял, почему это названо туториалом по паттернам отказоустойчивости. Например, откуда взялось , что всего их 6? Какого-то канонического списка из шести паттернов нет. А bulkhead, load shedding, backpressure, graceful degradation тогда куда? С retry тоже всё не сводится к идемпотентности, exponential backoff и jitter. Если не ограничить число попыток, не иметь общего deadline и какого-то retry budget/throttling, то при проблемах downstream повторные запросы вполне могут просто добить и без того перегруженный сервис. В том же gRPC retry throttling существует не для красоты. И сам по себе неидемпотентный HTTP-метод ещё не означает, что операцию нельзя безопасно повторить. Тот же POST вполне можно сделать идемпотентным на уровне бизнес-операции, например через idempotency key. Также странный пример с deadline. В тексте говорится, что вызывающий код получит codes.DeadlineExceeded, но в самом Whoami любая ошибка, кроме Unauthenticated, сразу превращается в ErrIAMUnavailable. То есть из приведённого кода этот DeadlineExceeded наружу как раз не выйдет. Плюс тут немного смешаны два уровня: context.WithTimeout приводит к context.DeadlineExceeded, а codes.DeadlineExceeded это статус gRPC. Для gRPC cancellation отправляется серверной стороне и дальше может распространяться по цепочке через context. Другое дело, что серверный код должен эту отмену действительно учитывать. С rate limiting похожая история. Несколько реплик не означают автоматически, что локальный limiter становится бесполезен и надо тащить Redis. Local и global limiting решают разные задачи. Локальный limiter вполне нормально защищает конкретную реплику. А Redis в критическом пути, кстати, ещё и добавляет новую распределённую зависимость, с отказами которой тоже придётся что-то делать. С Circuit Breaker подсчёт последовательных ошибок вполне нормальный пример, но опять же только один из вариантов. Есть rolling window, failure ratio, slow calls, своя классификация ошибок и т.д.

Хороший разбор! Небольшое уточнение по heap defer. В тексте сначала правильно сказано про per-P pool, но дальше есть формулировка, что после использования запись _defer остаётся до тех пор, пока её не подберёт GC. Насколько я понимаю runtime, обычно это работает немного иначе: popDefer сразу снимает запись и возвращает её в deferpool, а newdefer потом пытается переиспользовать её оттуда. GC здесь всё-таки участвует, но не в смысле “каждый выполненный heap defer потом ждёт сборки”. При GC очищается центральный defer pool, после чего находившиеся там записи становятся доступны для сборки, ограниченные per-P пулы при этом сохраняются. Поэтому и malloc: ✓ в итоговой таблице я бы читал именно как “может потребоваться новая heap allocation”, а не как malloc на каждое выполнение defer.

Ну да, прямо так взяли и раскрыли исходный код Макса, Яндекс-Браузера. Сказочники

1
23 ...

Информация

В рейтинге
587-й
Откуда
Новороссийск, Краснодарский край, Россия
Зарегистрирован
Активность

Специализация

Системный инженер, Архитектор программного обеспечения
Ведущий
Golang
PostgreSQL
Linux
ООП
Базы данных
Git
Python
C++
Оптимизация кода
Разработка программного обеспечения