Анонс платформы самоучителя по Solidity

Я планировал потрать еще некоторое время, чтобы полностью доработать платформу, где будут выложены все модули курса по Solidity + модуль по Foundry + модуль с практикой аудита кода, но текущие веяния в области ограничений Телеграмма, заставляют выпускать все раньше.

Сама платформа готова на 98% - 99%, я все еще просматривая материал на предмет каких-либо недочетов, некорректного отображения, мелких багов и т.д. И, в целом, все готово к открытию.

Вчера я открыл доступ к платформе для учеников Летнего модуля 3 потока. Собираю пока обратную связь. Кстати, если вы проходили Летний и 3 модуль 2 потока, то для вас доступ будет бесплатный, как я и обещал ранее. У вас будет доступ не только к материалам на каналах Телеграм, но и на одном ресурсе все вместе, в удобном формате.

Для всех желающих до конца февраля будет специальная цена на весь курс - 5000 рублей. Позже цена будет выше, и можно будет купить модули по отдельности.

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

Если после первых тестов на платформе все будет хорошо, то общий доступ открою уже в следующую среду - 18 февраля.

Всем хорошего дня и продуктивной работы!

#solidity

Что будет с Solidity и блокчейном?

На выходных в компании друзей подняли эту тему и пришли к выводу, что будет застой до одного переломного момента...

Драйвером роста в начале 2020 годов послужило то, что это были "новые деньги", где можно было быстро заработать. Появилось множество обменников и первые DeFi приложения, которые поняли смысл торговых операций и быстро вошли в топ на фоне, того, что остальные клепали свои токены.

Затем маркетинг и NFT подлили масла в огонь, и тогда "вход" в крипту через картинки стал проще. Знаменитости и артисты продавали NFT своим подписчикам и это считалось писком моды.

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

И все сошло на нет на 80% - 90%. Про NFT все забыли, мемкоины остались спекулянтам, а web3 захватили институционалы и правительство разных стран.

Solidity и блокчейн никуда не денется, туда вложено слишком много денег. Но и однотипные "Uniswap" / "Aave" / "GMX" уже всем приелись: инвесторы не дают деньги на их развитие командам, а без хорошего маркетинга ни один проект не взлетит.

Так что же за переломный момент, к которому мы пришли в компании?

На зарубежных сайтах я все чаще вижу возможность оплатить криптой за какой-либо сервис или товар. Представьте на секунду, что будет если такие платежи адаптирует Steam, Amazon, Spotify и другой популярный маркетплейс! А это уже потихоньку на подходе.

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

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

Это даст очень большой буст всей сфере. Будут появляться уже не финансовые проекты в web3, а много SaaS, агентов и т.д., которые начнут упрощать жизнь и продавцам и покупателям.

Когда это будет? Думаю, когда все успокоятся с ИИ и агентами. А там, кто его знает. Но тенденции идут.

А как вы думаете?

#web3

🎉🎉🎉 Запуск платформы SoliditySet 🎉🎉🎉

Как и обещал, сегодня запускаю платформу самоучителя по Solidity с нуля для всех!

Для меня эта платформа очень ценна, так как это результат моей работы последних трех лет в обучении других языку Solidity. Каждый урок я писал сам, перерабатывая знания и стараясь сделать информацию максимально понятной и простой для новичков (и это заметили первые ученики на модулях!).

В итоге на платформе собрано:

1. 100+ уроков для тех, кто никогда ранее не программировал;
2. 20+ уроков по тестированию смарт контрактов в среде Foundry;
3. 70+ заданий для практики аудита кода;
4. 80+ практических заданий;
5. 50+ продвинутых челленджей для практики;
6. 150+ вопросов для самопроверки и подготовки к собеседованию;
7. 5 практикумов для проверки навыков после каждого модуля;
8. 10+ возможных проектов для портфолио;

Это, вероятно, самый большой и полный самоучитель по Solidity в ру сегменте!

И все это на удобной платформе, где вы можете отслеживать прогресс и проходить каждый урок в своем темпе!

P.S. Важно сказать, что там нет видео уроков! Я никогда не записывал видео и вся информация там в текстовом формате!

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

Кроме того, нужно сказать, что это ранняя версия платформы, и она будет обновляться в течение некоторого времени. В планах добавить еще несколько уроков в каждый модуль, а также создать отдельный раздел, куда войдут переводы со многих ресурсов (RareSkills, Cyfrin, и т.д.) для общего развития.

Стоимость доступа будет повышаться со временем.

До конца февраля она составляет 5000 рублей (65 USDT), с марта будет повышение на 1000.

На данном этапе я еще не добавил опцию покупки на сайте. Поэтому после регистрации на платформе, вам нужно написать мне (@zaevlad). Я пришлю актуальные реквизиты для оплаты и открою доступ.

Сайт самоучителя - SoliditySet

Там открыты первые три урока для общего доступа, чтобы вы могли оценить, подходит ли вам этот формат или нет перед покупкой.

Всем легкого обучения!

#solidityset

Ошибка в Solidity и новый бенчмарк

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

Команда Solidity раскрыла детали критической ошибки, которая пряталась в версиях компилятора с 0.8.28 по 0.8.33. Проблема проявлялась только при использовании IR-конвейера и была связана с коллизией имён вспомогательных функций. Если в коде одновременно использовалась очистка переменной временного хранилища и постоянного хранилища одного типа, компилятор путал инструкции. Вместо очистки временной ячейки он мог обнулить слот в постоянной памяти, что потенциально способно «сбросить» владельца контракта или нарушить логику блокировок. Ошибка уже исправлена в версии 0.8.34. Хотя в мейннете нашлось всего три уязвимых контракта, инцидент напоминает о том, как важно следить за обновлениями инструментов, особенно при использовании новых фич вроде transient storage.

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

#news

Что почитать?

Проснулся сегодня с явным нежеланием работать. На улице хоть и -2, но солнце светит уже по весеннему, и хочется просто отдыхать, а не фиксить баги и учить MatPlotLib...

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

1. System Design. Подготовка к сложному интервью. Алекс Сюй.

Первая книга, которую должны прочитать все вайбкодеры, да и просто начинающие разработчики. Здесь в понятной манере и простым языком объясняются базовые принципы архитектур компьютерных систем: какую базу данных выбрать, как работает кеш, что такое CDN, распределение трафика, нагрузка и организация серверной части. Очень достойная книга, чтобы начать разбираться в этих понятиях!

2. System Design. Машинное обучение. Али Аминиан, Алекс Сюй.

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

3. Прикладное машинное обучении и искусственный интеллект для инженеров. Джеф Просиз.

Вот это отличная книга для тех, кто уже познакомился с нейронками и хочет копнуть глубже с тем, как работают сети в своей основе. Тут раскрываются темы регрессионного анализа, классификационных моделей, опорные векторы, обучение с помощью keras/tensorflow, обнаружение лиц и распознавание изображений и т.д. Много примеров с кодом. Единственное что, может быть сложной в языке: если вы никогда ранее не сталкивались с определениями в машинном обучении, то придется много гуглить.

4. Байесовская статистика. Star Wars, резиновые уточки и многое другое.

Книга за которой долго гонялся. Не мог найти в РФ и ждал ее несколько недель из Китая. Еще не успел прочитать ее, только просмотрел несколько глав. Прекрасное, легкое и очень простое объяснение предсказательной статистики и вероятностных моделей. Как вы можете знать, что современные нейронные сети "под капотом" используют предсказательные алгоритмы для генерации токенов. Эта книга может помочь вам понять на простых примерах, как это все работает в сетях.

5. Алгоритмы искусственного интеллекта. Ришал Харбанс.

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

6. Высоконагруженные приложения. Мартин Клепман.

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

Полагаю, что читать ее лучше после первой книги Алекса Сюя, чтобы складывалось общее понимание работы систем.

7. Поиск на основе искусственного интеллекта. Трей Грейнджер, Дуг Тернбул, Макс Ирвин.

Вот это отличная книга о том, как работает поиск. Читаю ее сейчас. Если вы когда-нибудь задумывались, почему поиск на сайте работает так "криво", или почему он выдает массу результатов подобных моим прошлым запросов - эта книга для вас. Детально разбираются системы алгоритмов поиска и рекомендаций, а также использование нейронных сетей для выдачи релевантных результатов. Книга огонь!

8. Конструкции. Джейсм Гордон. Это книгу давно забросил в корзину и все никак не мог купить ее. Пришлось просить в подарок на Новый Год. Единственное, о чем пожалел: почему я не купил ее раньше!

Эта книга не про IT, это больше популярное чтиво о том, как работает физика в конструкциях. Язык и объяснения невероятно простые. Если бы так физику преподавали в школе, я бы точно получал одни пятерки! Потрясающие графики и фотографии, рисунки и силуэты, описания базовых принципов растяжения и деформации и много другое! Просто зачитываюсь в свободное время и наслаждаюсь, как можно просто писать о таких сложных вещах!

Есть еще несколько других интересных книг, но расскажу о них позже, если вам зайдет такой формат в постах.

Так же буду рад получить от вас другие рекомендации, что еще моно почитать!

#books

Алгоритмы. Обход в глубину (DFS)

После небольшой паузы мы продолжаем разбирать различные алгоритмы.

Обход в глубину (DFS) — это один из фундаментальных алгоритмов на графах, и его легче всего понять через аналогию с исследованием пещеры. Представь, что ты стоишь в системе туннелей с множеством разветвлений. Твоя стратегия заключается в том, чтобы выбрать первый попавшийся проход и идти по нему до тех пор, пока не упрешься в тупик. Только тогда ты возвращаешься назад к последнему перекрестку, где еще есть неисследованные пути, и пробуешь следующий туннель. Эта логика, где глубина проникновения важнее ширины охвата, и лежит в основе алгоритма DFS.

Рассмотрим небольшой граф. Предположим, у нас есть узлы, соединенные между собой: A связан с B и C; B связан с A, D и E; C связан с A и F; D связан только с B; E связан с B и F, а F, в свою очередь, связан с C и E. Если начать обход с узла A, DFS будет двигаться следующим образом: сначала мы попадаем в A, затем углубляемся в B, оттуда — в D. Достигнув D, мы понимаем, что это тупик (сосед B уже посещен), поэтому возвращаемся обратно в B и идем по следующему пути в E. Из E переходим в F, который тоже оказывается тупиком (все соседи посещены или ведут назад). После возврата в E и затем в B, мы наконец возвращаемся в A и идем в C, но обнаруживаем, что C уже был посещен через F. Итоговый порядок посещения узлов будет таким: A, B, D, E, F, C.

Граф:
        A
       / \
      B   C
     / \   \
    D   E   F
         \ /
          (F связан с E и C)

DFS от A пойдёт так:
A → B → D (тупик, назад) → E → F (тупик, назад) → назад → C (уже посещён через F)

Порядок посещения: A, B, D, E, F, C

В этом заключается ключевое отличие DFS от другого известного алгоритма — поиска в ширину (BFS). BFS работает подобно кругам на воде: сначала исследуются все соседние узлы, затем их соседи, распространяясь равномерно во все стороны. DFS же напоминает нить Ариадны в лабиринте: он всегда идет до конца по выбранному пути и лишь затем возвращается.

Граф:           BFS (в ширину):        DFS (в глубину):
    A           Уровень за уровнем     Ветка за веткой
   / \          A                      A
  B   C         B, C                   B, D, E, F, C
 / \   \        D, E, F
D   E   F

Для реализации DFS можно использовать два основных подхода, которые делают одно и то же, но разными средствами: рекурсию и явный стек. Рекурсивный метод полагается на стек вызовов самой программы. Когда мы пишем функцию, которая вызывает саму себя для обработки соседей, язык программирования автоматически запоминает точку возврата. Однако здесь есть важная особенность Python: не стоит задавать значение аргумента visited по умолчанию как пустое множество (set()), так как изменяемые объекты создаются один раз и будут переиспользованы во всех вызовах функции. Вместо этого нужно создавать его внутри функции, если оно не передано.

Пример 1

Чтобы лучше понять, как работает рекурсия, можно проследить её выполнение по шагам. Входя в узел A, мы помечаем его как посещенный и записываем в результат. Затем смотрим на соседа B, который еще не посещен, и вызываем функцию для B. Внутри вызова для B повторяется та же логика: добавляем B в путь и идем к его первому непосещенному соседу D. В D тупик, и функция возвращает результат обратно. Далее в B очередь доходит до следующего соседа — E. Из E попадаем в F, а из F — в C. Когда все пути исчерпаны, результаты склеиваются и возвращаются наверх.

Пример 2

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

Пример 3

Процесс итеративного обхода можно наглядно представить в виде таблицы, где видно, как меняется содержимое стека на каждом шаге. Начинаем со стеком, содержащим A. Извлекаем A, помечаем его и добавляем в результат, а затем кладем в стек его соседей C и B в обратном порядке (чтобы B оказался сверху). Затем извлекаем B, затем D, и так далее, пока стек не опустеет.

Шаг | Стек (вершина →)   | Берём | visited         | result
----|--------------------|-------|-----------------|------------------
 0  | [A]                |  A    | {A}             | [A]
 1  | [C, B]             |  B    | {A,B}           | [A,B]
 2  | [C, E, D]          |  D    | {A,B,D}         | [A,B,D]
 3  | [C, E]             |  E    | {A,B,D,E}       | [A,B,D,E]
 4  | [C, F]             |  F    | {A,B,D,E,F}     | [A,B,D,E,F]
 5  | [C, E*, C]         |  C    | {A,B,D,E,F,C}   | [A,B,D,E,F,C]
    (* E уже в visited — пропустим при извлечении)

Финальный результат: [A, B, D, E, F, C] ✓

Этот код, по сути, является готовой реализацией итеративного DFS, где стек берет на себя работу, которую в рекурсивной версии выполняет стек вызовов. Каждая часть здесь важна: множество visited отслеживает уже обработанные узлы, список stack хранит узлы, которые предстоит обработать, а цикл while работает, пока есть что извлекать.

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

Граф БЕЗ цикла:     Граф С циклом:
    A                   A
   / \                 / \
  B   C               B   C
  |                   |\ /
  D                   | X
                      |/ \
                      D   E

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

Пример 4

Как именно это работает, можно увидеть на примере графа с циклом. Начиная с A, мы идем в B, затем в D. В узле D видим соседа B, который уже есть в rec_stack. Это и есть сигнал о наличии цикла.

Пример 5

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

Пример 6

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

Лабиринт:        DFS может пойти так:      BFS пойдёт так:
  S               S→A→C→E→EXIT             S→A (длина 1)
 / \              (длина 4)                S→B (длина 1)
A   B             Хотя существует          S→A→C, S→B→EXIT
|   |             S→B→EXIT                 Найдёт S→B→EXIT
C  EXIT           (длина 2)!              (длина 2) первым
 \ /
  E
  |
 EXIT

DFS нашёл путь длиной 4, хотя есть путь длиной 2.
BFS всегда находит кратчайший путь.

Сравнивая эти два подхода для лабиринта, можно выделить несколько критериев. Для задачи нахождения любого выхода оба алгоритма работают, но DFS требует меньше памяти. Для поиска кратчайшего пути BFS гарантирует результат, а DFS — нет. В глубоких лабиринтах рекурсивный DFS рискует переполнить стек, тогда как итеративный и BFS безопасны. В широких лабиринтах BFS может потребить много памяти, а DFS остается эффективным.

Что касается вычислительной сложности, то и для DFS, и для BFS она одинакова. Временная сложность составляет O(V + E), где V — количество вершин (узлов), а E — количество ребер. Это объясняется тем, что алгоритм посещает каждую вершину ровно один раз и просматривает каждое ребро также один раз. Пространственная сложность в худшем случае составляет O(V) — память нужна для хранения множества посещенных узлов и, в случае итеративной реализации, стека.

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

#algorithm

Фиксы SoliditySet

Спасибо всем, кто сообщал мне о проблемах на платформе и подсказывал лучшие решения для тех или иных случаев. Сегодня был выполнен очередной фикс:

1. Были исправлены некоторые не работающие ссылки;
2. Обновлено отображение на мобильных экранах: немного удобнее использовать на планшетах;
3. К нумерации уроков были добавлены заголовки уроков;
4. Подсказки и ответы для модуля 5 (практика поиска уязвимостей) были скрыты под спойлером. (Тут я еще думаю как сделать это красивее...).
5. Исправлен порядок вывода некоторых уроков.
6. Откорректированы мелкие недочеты.

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

#solidityset