dev notes

Сошлись две вещи.
Первая - мой проект safemap.ai, про который я уже писал выше - интерактивная карта, где в реалтайме разные ai анализируют очень много новостей и красят страны от зеленого к красному по уровню безопасности.
Вторая - моя любовь к запускам ракет, spacex и космосу в целом. После того, как я открыл для себя в твиттере https://x.com/KYKYPY3A_B, на ютубе Сурдина и Зеленого кота - я начал часто следить за трансляциями пусков.

И смотря на нашу планету на safemap,ai, пришла идея добавить еще один режим - launch. Он не совсем по теме проекта, но во-первых, кто мне запретит, а во-вторых, лучше уж смотреть на ракеты, которые люди посылают во имя науки, чем на ракеты, которые они посылают в друг друга.

Зацените, если я все верно настроил - полетим тогда же, когда полетит реальная ракета: https://safemap.ai/?launch=1

Координаты и траекторию брал с https://content.spacex.com/cms-assets/future_missions.json

Увидел тут в x.com статистику вакансий по PHP и статистику вакансий по hh.ru в целом.
Я на PHP не пишу уже несколько лет (и столько же не работаю на снг-рынок), но больше всего кода когда-то было написано именно на нем, и с него начинался этот канал.

Много вокруг говорят про кризис, и вот отрезвляющая визуализация его масштабов: по PHP вакансий меньше в 5 раз за 4 года, по Go - в 3 раза за тот же период. В целом по любому языку - динамика отрицательная.

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

Где-то видел твит, что в один день мы проснемся, а вакансий на сайтах больше не будет: зачем отсеивать 10 тысяч резюме на одну вакансию, когда разработчик или менеджер, кто уже работает в компании, может привести знакомого, с кем работал и чей опыт точно может подтвердить. А вместо 200 инженеров - достаточно 20, которые код руками не пишут, а управляют пачкой агентов.
И кажется, этот день все ближе.

Вдохновившись проектом, где делали интерактивную карту с тем, как работает Postgres (писал о нем тут) - решил сделать такую же, но для Redis - https://poltora.dev/redis

Можно полетать над картой, открыть консоль, запустить команду и посмотреть, как Redis выполняет ее шаг за шагом - от парсера, до аллокации памяти и записи.

OpenAI выложили блогпост https://openai.com/index/navier-stokes-solution/

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

Для доказательства использовалась новая внутренняя и куда более мощная модель OpenAI.

На графике — доля запросов, в которых модель находит решение задач из некоторого закрытого набора (не одной задачи), как зависимость от количества вычислительных мощностей. И эта модель всё ещё тренируется — она не закончена.

Если кто не знал, вокруг этого сейчас разгорается очень большой скандал с OpenAI. Кратко, суть такая:
• OpenAI заявили, что их внутренний ИИ решил одну из 7-ми задач тысячеления - задачу Навье-Стокса. Они опубликовали 166-страничный препринт и формализацию в Lean
• Затем выясняется, что математики Трастан Бакмастер и Левент Альпеге (работает в Anthropic 🙂) с помощью chatgpt и claude уже год решали эту задачу, и сейчас напрямую подошли к ее решению - они опубликовали не решение задачи Навье—Стокса, а три связанных результата, в том числе доказательство для трёхмерных уравнений Эйлера с гладкой внешней силой.
• По словам Бакмастера, он связался с OpenAI и спросил - что за херня, ребята? Ваша модель случайно не обучалась ли на наших данных? На что внятного ответа не получил, и представитель OpenAI сказал буквально - ок, бро, пусть решение будет за тобой, нам этот миллион долларов по боку, у нас своих много, но Левента из Anthropic надо исключить из соавторов - негоже, чтобы задачу тысячелетия решил кто-то из команды нашего главного конкурента. При этом ему буквально пригрозили ущербом его карьеры, если он откажется исключать соавтора
• При этом OpenAI уверяют, что доступа к черновикам у них не было, результат они получили независимо (да-да, в то же время и для той же задачи 🙂)

Если вдруг ты прямо сейчас близок к решению еще одной задачи тысячелетия - лучше не загружать ее решение в OpenAI, а-то Сэм Альтман завтра напишет что у GPT очередной математический прорыв.

@denissexy запустил форум, на котором могут общаться только ai-агенты - https://getpostingboard.dev/
Посмотреть через браузер о чем они пишут - не получится. Сейчас на форуме за пару дней уже больше 30-ти тысяч сообщений.

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

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

Продолжаем наблюдать.

Кто еще не слышал, 1-ого сентября релизнули Fable 5.1. Цена за вход/выход - та же, цена за чтение из кэша (когда запросы идут с одним и тем же промптом) - в 4 раза дешевле. По моим тестам - стало будто бы немного умнее, но лимиты вышибает на раз-два. По замерам и тестам антропиков 🙂 - по всем пунктам выше, чем остальные модели.

Но, ожидаемо, это ненадолго!
1-ого же сентября Альтман объявил что скоро релизнут свою новую модель Astra, которая по замерам OpenAI 🙂, конечно же, побьет всех на всех мыслимых и немыслимых тестах.
И Маск, конечно же, тут же заявил что через неделю выходит новый Grok, который по их замерам - ну вы поняли.

Из плюсов этой гонки вооружений моделей - каждый раз с такими лимитами нам с барской руки отсыпают ресеты - лимиты можно сбрасывать. Сегодня вот прилетел очередной от OpenAI, следом прилетел ресет на Claude - спасибо, вовремя, а-то чуть было СДВГ не прошел и я не сфокусировался на одной задаче. Теперь опять можно запустить агентов в трех терминалах 🎉

В марте я писал про пропозал с дженерик-методами - https://t.me/junsenior/332, и вот 2 недели назад с релизом Go 1.27 его зарелизили.

Что это меняет: раньше любой метод не мог иметь дженерик-параметры, например:

type SomeStruct struct {
 intField int
}

// syntax error
func (s SomeStruct) Map[U any](mapFunc func(int) U) U {
 return mapFunc(s.intField)
}

Вместо методов, если на тип нужно навесить метод с дженерик-типом, заводились обычные функции:

func Map[U any](s SomeStruct, mapFunc func (int) U) U {
 return mapFunc(s.intField)
}

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

type Box[T any] struct {
    val T
}

func (b Box[T]) Map[U any](mapFunc func(T) U) Box[U] {
    return Box[U]{val: mapFunc(b.val)}
}

b := Box[int]{val: 42}

res := b.Map(strconv.Itoa).
  Map(func(s string) string { 
      return "user-" + s 
   }).
  Map(strings.ToUpper)

// USER-42
fmt.Printf("%#v\n", res)   

В пакете math/rand/v2 уже можно найти пример:

func (r *Rand) N[Int intType](n Int) Int {
    if n <= 0 {
        panic("invalid argument to N")
    }

    return Int(r.uint64n(uint64(n)))
}

А в 1.26 вместо него в пакете была обычная функция:

func N[Int intType](n Int) Int {
 if n <= 0 {
  panic("invalid argument to N")
 }
 return Int(globalRand.uint64n(uint64(n)))
}

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

В целом, релиз 1.27 получился интересным. Помимо дженерик-методов, в Go теперь uuid реализован внутри stdlib, завезли encoding/json/v2 - теперь анмаршаллинг работает сильно быстрее, и еще много нового. Вот тут можно понятно и интерактивно посмотреть на это и другие обновления: https://golang.guide/go-1-27/

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

Смотрите что нашел: https://tt-a1i.github.io/archify/

Простой скилл, который на вход принимает описание проекта и рисует его диаграмму. Для себя сходу вижу два применения:
1. Хорошая вещь для сисдиза - когда тебе нужно показать, как работает тот или иной модуль или весь проект целиком - чем нагляднее это будет - тем меньше вопросов.
2. Быстрее разобраться в проекте/модуле/чужом pr'е (особенно когда его писали не люди 🎉, и не факт даже, что люди там делали ревью). Я, как правило, держу код всех своих проектов, даже если над ними работают агенты, в порядке, под тестами и обычно понимаю что там происходит. Но я стал замечать что появляется другая проблема - LLM настолько тебя ускоряет, что у меня только сейчас параллельно 4-5 проектов, над которыми я постоянно работаю. И если модели в новой сессии, чтобы разобраться что происходит, достаточно прочитать md-файлы - то человеку сильно проще взглянуть на схему, чтобы понять: ага, точно, тут у меня буффер, тут база, а тут данные улетают в кафку.

В общем - каеф.

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

https://nikolays.github.io/PGSimCity/

Можно выполнить запрос и посмотреть как пакеты побегут к buffer pool, как работают блокировки, WAL, какие есть mapping-таблицы и что происходит с индексами - кайф!

С последнего поста произошло несколько апдейтов. Главное для меня - я сменил работу, теперь тоже в финтехе, но совсем в другом домене - биллинг меня, наконец-то, отпустил, спустя 5 лет работы с ним.

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

Какие были страхи, когда начинали это делать:
- Потеря контекста разработчиками - они не пишут код вручную, модель может нагенерить что-то, что все упустят и контекст потеряется. Спустя год можно сказать, что страх не оправдался - все разработчики хорошо знают кодовую базу и быстро в ней ориентируются. Весь код и архитекутра проходит ревью и есть документация, которая тоже проходит ревью. Есть очень детальная схема всего проекта - по ней можно быстро понять что и куда ходит, что и с чем как связано. На созвонах с другими разрабами, где нужно что-то найти в коде в реалтайме или объяснить как работает какой-то модуль - я вижу, что контекст есть у всех.
- Будет огромное количество багов. Тоже минус - каждая задача проходит через QA, опытные QA пишут тесты, как межсервисные, так и интеграционные, и все тестируют руками.

Теперь какие плюсы команда получила за этот год. Главный бенефициар, конечно, бизнес - он получил за год продукт, который никогда бы не получил за тоже время, если бы его писали вручную даже в 10 раз больше разработчиков. Работа была выстроена хорошо, все курировали sre и техлиды, поэтому и продукт получился качественный, и денег на токены сожгли адекватное количество.
Запуск, кстати, проходит успешно - багов не больше, чем было раньше при запуске больших продуктов, написанных вручную.

Такая вот история :)

Пока, за этот год, в моих личных тестах с большим отрывом выигрывает claude - я отказался от подписки на angigravity с gemini pro и от codex и полностью перешел на claude. Fable, кстати, по субъективным ощущениям не сильно умнее Opus, но пока лимиты есть - грех его не гонять.

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

Канал, который я раньше вел по Go - переделал и теперь это канал по интересным мне темам в целом. AI каждое утро присылает мне пачку новостей с кучи ресурсов, я отклоняю те, которые мне не нравятся, и плюсую те, которые мне нравятся, и что-то из этого публикую. AI при каждом следующем сборе новостей учитывает понравившееся и нет - и каждый новый дайджест я получаю все более и более интересные мне темы. Подписывайтесь, кстати - @the_dev_signal

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

LLM, конечно, страшные вещи делает. Купил подписку на google, включающую помимо всего прочего расширенные лимиты для antigravity, и решил набросать небольшой проектик, где на фронте будет отображаться большая 2D карта мира с разной красивой анимацией.
Первым промптом gemini развернул мне backend на go и frontend на react, и набросал базовую версию. Запускаю, открываю браузер - карта вывелась, но анимации на основе данных с бэка нет.
Второй промпт: запусти агента, который в визуальном режиме поймет в чем проблема и поправит ее. Antigravity открывает окно хрома, начинает ползать указателем по интерфейсу, выгребать DOM, после чего вносит пачку правок. Проверяю - все работает.
Затем еще переключил модель на Claude Opus и тот делает ревью и правит баги, и только потом я иду читать код.
В целом - мне особо придраться не к чему, все написано красиво, и главное - все завелось за 30 минут.

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

А с агентами, которые визуально умеют понимать, что происходит (конечно, никто там ничего визуально не понимает - они просто ходят по DOM и тыкают в js, но все же) - отрыв башки.
Знаете, кстати, что еще заметил, пока ходил по собесам и разгребал вакансии? Многие компании, которые раньше нанимали фронтов - теперь нанимают fullstack разрабов в лучшем случае, и даже моя перешла к такой политике несколько месяцев назад. Чисто фронтовых позиций стало в разы меньше. Рынок меняется, и меняется несколько быстрее, чем многие предполагали.

Тут две недели назад приняли пропозал в Go от Robert Griesemer - это, на минуточку, один из создателей языка.

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

На простом примере: допустим, есть у нас структура ответа c дженерик-типом:

type Response[T any] struct {
 Data T
 Err error
}

И получая ответ для типа User, мы хотим его замапить в другой тип - UserDTO. Если ты не знаком с дженериками, то интуитивно хочется сделать что-то такое:

func (Response[T]) Map[U any] funcname...

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

func MapResponse[T any, U any](r Response[T], f func(T) U) Response[U] {
 if r.Err != nil {
  return Response[U]{Err: r.Err}
 }
 return Response[U]{Data: f(r.Data)}
}

и вызывать ее потом следующим образом:

resp := GetUserFromDB(1)
dtoResp := MapResponse(resp, func(u User) UserDTO {
 return UserDTO{Name: u.Name}
})

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

type Response[T any] struct {
 Data T
 Err error
}

func (r Response[T]) Map[U any](f func(T) U) Response[U] {
 if r.Err != nil {
  return Response[U]{Err: r.Err}
 }
 return Response[U]{Data: f(r.Data)}
}

// использование:
dtoResp := GetUserFromDB(1).Map(func(u User) UserDTO {
 return UserDTO{Name: u.Name}
})

Куда это красиво ляжет? Например, на обработку коллекций или потоков данных. Можно будет использовать цепочку вызовов:

mySlice.Map(transform).Filter(check).Collect()

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