Pull to refresh

Comments 139

А вам не кажется, что это буквально то же самое, что происходило с программированием во время популяризации интернета? Это ведь тогда появился подход "зайти на StackOverflow -> копировать -> вставить -> подогнать по месту", сейчас он просто стал удобнее. Без знаний о проекте у программиста нейронка не спасет.

Если раньше

  подход "зайти на StackOverflow -> копировать -> вставить -> подогнать по месту"

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

Вижу надвигающуюся катастрофу в индустрии ((

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

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

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

В целом это все в том или ином виде происходит все время, уверен что 40 лет назад были статьи(если был бы интернет) на тему вот вышли эти ваши языки высокого уровня, типа Си, раньше люди думали какие они инструкции отправляют в процессор, а сейчас могут бездумно вызвать алгоритмы квадратичной сложности одной строкой. А потом про RAD среды программирования, что мол вот раньше надо было думать какое WinAPI ты вызываешь и какие параметры передаешь, а сейчас перетянул виджет на форму и довольный сидишь.

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

Вероятно и сейчас чуть позже появятся инструменты на основе ИИ которые будут показывать проблемные места в коде

Так хоть сейчас можно попросить нейронку сгенерить код, а потом этот код отдать на ревью другой нейронке.

Весьма увлекательное занятие, скажу я вам.

а второй код отдать третьей нейронке, чтобы пользовалась.
а третий - четвёртой, чтоб ругала.

а кто-то потом ходить подметать после первых

За тройную зарплату дай Бог :)

Это обязательно! )))

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

С ИИ вы получаете один вариант ответа. И никакой дискуссии, никакой возможности определить степень достоверности.

Откуда ИИ берет информацию? Из того, что написано в сети. А если туда начнут попадать ответы ИИ на предыдущие вопросы? И следующее поколение ИИ начнет "обучаться" на ответах предыдущего? Получим бредогенератор в режиме самовозбуждения.

У меня есть пример, когда ИИ на вопрос "какой вариант кода эффективнее" дает ответ диаметрально противоположный правильному. Т.е. предлагает неэффективный вариант кода. Хотя и рабочий. Но если вы работает с HiLoad, что в лучшем случае вас макнут лицом в грязь на ревью и заставят переделывать. В худшем - протащите в прод код, который через какое-то время придется переделывать.

Но чтобы это понять, надо знать тему лучше чем ИИ. А если вы ее знаете, то ИИ вам не нужен.

Да, нужно менять подходы к обучению ИИ. Как обучался хороший программист?

Сперва окончил школу, знает математику, геометрию, информатику. Затем в институте прочитал 2-3 книги по программированию. Написал штук 10 несложных программ.

Затем работал, написал около 10000 строчек кода, отладил и что-то начал в этом понимать.

Ему не нужно было прочесывать весь Git и SO, но программист уже очень хорош. Подобный подход можно применить к обучению ИИ, и тогда не так уж и важно будет, что там пишут на SO. Вопрос только подойдут ли сегоднящние архитектуры нейронных сетей (трансформер) для такого обучения или надо будет придумывать что-то новое.

Вот тут не очень понятно как этому научить ИИ.

Когда вам на том же SO отвечает живой человек, он дает ответ на основе собственного опыта (и вы еще можете посмотреть рейтинг этого человека - насколько он "авторитетен" в сообществе). И в общем случае он может на реальных примерах показать почему лучше так а не иначе.

У ИИ нет "собственного опыта". Он просто дает вам "выжимку" из того, что написано в сети. Со всеми вытекающими последствиями. Если в сети есть один "правильный" ответ и 10 "неправильных" (а это вполне вероятная ситуация - на один вариант от профессионала будет приходиться десяток поделок от школьников) - скорее всего рейтинг "неправильного" ответа будет выше.

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

Допустим у нас есть нулевая или минимально предообученная на английском языке сеть. Попросим ее сгенерировать миллион функций сортировки на языке C, длиной не более 300 символов. Из этого отберем, те где встречаются правильные шаблоны for, if, return, подкрепим на них. Затем снова миллион функций, и отберем те что компилируются. Потом снова, но отберем, те что удачно сортируют или порядок сортировки наиболее близок к правильному. Далее будем отбирать, те которые исполняются за наименьшее время.

Потом будем просить генерировать все более и более сложные алгоритмы, переходить на другие ЯП.

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

В целом разумно. Но это отдельный процесс ведь. И кто-то должен этим заниматься... А это огромный объем работы...

раз нашлись силы на шахматы, го, доту и много чего еще, то найдутся и на разработку)

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

тут бы конечно специалистов спросить, на мой взгляд RL может дать именно то чего сейчас не хватает - опыт и глубокое понимание основ разработки. А сейчас, когда скормли все доступные исходники, то наделили просто информацией. И, возможно, как раз можно с помощью RL соединить информацию и опыт. А значит RL нужно будет в умеренных количествах.

Стоп, стоп. Шахматы — игра с нулевым исходом. Там учитель вообще не нужен.

ну как-то же надо объяснить модели куда ходить, чем ходить, кто-то должен подсказать, что такое хорошо, что такое плохо

ну как-то же надо объяснить модели куда ходить, чем ходить

Да, но правила шахмат — довольно легко формализуемы.

подсказать, что такое хорошо, что такое плохо

В случае шахмат — нет. Там не было обучения с учителем, вообще. Выиграл — хорошо, проиграл — плохо. И так сто миллионов миллиардов раз.

и так и программированием так же можно - код компилируется, тесты проходит - хорошо, нет - плохо.

то что правила плохо формализуются да есть проблема, даже люди между собой спорят, как правильно код писать, но это постепенно будет преодолеваться

Дело не в простоте формализации правил. Это преодолимо.

Дело в том, что разработка ПО — не игра с нулевой суммой. Для шахмат всё просто: выиграл? — правильно. Для ПО не существует понятия «правильно» (ну, в каком-то смысле можно property-based tests использовать, но они имеют не абсолютную область применения).

Вот у вас есть некий код, который вычислил расстояние до соседней галактики. Как вы предлагаете определять, всё в порядке, или он ошибся на пару миллионов парсеков?

нужно кому-то генерировать задачи и тесты под них, задачи можно составить вручную, а тесты наверное скоро текущий ИИ сможет и сам под задачи хорошо расписывать.

Ну составьте мне вручную тест по вышеозвученной задаче (у которой решение так-то неизвестно).

Эта задача никому не нужна, поэтому решение не известно, а есть много известных задач, например, олимпиадные задачи по программированию, на них уже есть сотни тестов, вот пусть на них тренируется. И когда там превзойдет человека, можно будет в реальные задачи пустить, например решать issue на github, кто-то под них должен будет написать тесты, люди (джуны) или другой вариант ИИ.

и так и программированием так же можно - код компилируется, тесты проходит - хорошо, нет - плохо.

Увы, но нет.

Вот пример (правда, он для экзотической платформы IBM i и экзотического языка RPG на ней).

Фрагмент кода №1

        dcl-f ECA10LF   disk(*ext)
                        usage(*input)
                        block(*yes)
                        usropn
                        keyed
                        qualified
                        static;
        
        dcl-ds dsECA    likerec(ECA10LF.ECAPFR: *all);
        dcl-s  LST      char(5);

        if not %open(ECA10LF);
          open ECA10LF;
        endif;

        for-each LST in %list('PPT': 'OMU': 'PE');
          setll (LST) ECA10LF;
          read ECA10LF.ECAPFR dsECA;
          
          dow not %eof(ECA10LF) and dsECA.ECALST = LST;
            read ECA10LF.ECAPFR dsECA;
          enddo;
        endfor;

Что по этому поводу думает ИИ

  1. Объявление файла: dcl-f ECA10LF объявляет файл ECA10LF как внешний файл на диске (*ext) с режимом доступа для чтения (*input) и блочной организацией (*yes). Файл открывается при запуске программы (*usropn), имеет ключевой доступ (*keyed), квалифицирован (*qualified) и статический (*static).

  2. Объявление структуры данных: dcl-ds dsECA объявляет структуру данных dsECA, которая имеет ту же структуру, что и запись ECAPFR из файла ECA10LF (используя likerec).

  3. Объявление переменной: dcl-s LST char(5) объявляет переменную LST как строковую с длиной 5 символов.

  4. Проверка открытия файла: if not %open(ECA10LF) проверяет, открыт ли файл. Если нет, то файл открывается с помощью open ECA10LF.

  5. Цикл по списку: for-each LST in %list('PPT': 'OMU': 'PE') создает цикл, который перебирает список значений ('PPT', 'OMU', 'PE').

  6. Установка ключа: setll (LST) ECA10LF устанавливает ключ файла ECA10LF на текущее значение LST.

  7. Чтение первой записи: read ECA10LF.ECAPFR dsECA считывает первую запись из файла ECA10LF и помещает ее в структуру dsECA.

  8. Внутренний цикл: dow not %eof(ECA10LF) and dsECA.ECALST = LST создает цикл, который работает, пока не достигнут конец файла (*eof) или пока значение поля ECALST в структуре dsECA не будет равно текущему значению LST.

  9. Чтение записей: read ECA10LF.ECAPFR dsECA считывает следующую запись из файла ECA10LF.

Тут все правильно.

Теперь фрагмент кода №2

        dcl-f ECA10LF   disk(*ext)
                        usage(*input)
                        usropn
                        keyed
                        qualified
                        static;
        
        dcl-ds dsECA    likerec(ECA10LF.ECAPFR: *all);
        dcl-s  LST      char(5);

        if not %open(ECA10LF);
          open ECA10LF;
        endif;

        for-each LST in %list('PPT': 'OMU': 'PE');
          setll (LST) ECA10LF;
          reade (LST) ECA10LF.ECAPFR dsECA;
          
          dow not %eof(ECA10LF);
            reade (LST) ECA10LF.ECAPFR dsECA;
          enddo;
        endfor;

Пояснение от ИИ

Этот фрагмент кода практически идентичен первому, с одним ключевым отличием: вместо read используется reade.

Тоже абсолютно верно.

А вот на вопрос какой фрагмент будет работать быстрее ИИ начинает бредить

reade - это более быстрый вариант read. Он оптимизирован для чтения записей с заданным ключом, что в нашем случае является эффективным, так как мы уже установили ключ файла с помощью setll.

Фрагмент 2 будет работать быстрее, так как он использует reade, что значительно оптимизирует чтение записей с заданным ключом, что значительно ускоряет обработку файла.

Потому что на самом деле все ровно наоборот. Быстрее будет работать код №1. Что подтверждается статистиками Performance EXplorer (PEX)

_QRNXDB_READ и _QRNXDB_READE - внутренние процедуры физического чтения с диска.

Что видим? При одинаковом количестве вызовов Read/ReadE, количество физических обращений к диску для Read в 8 раз меньше (601 201 против 5 406 300) чем для ReadE. Т.е. ReadE обращается к диску за каждой записью, а Read читает сразу по 8 записей и со 2-й по 8-ю берет из внутреннего кеша. Соответственно, для ReadE и потребление ресурсов процессора и время выполнения больше. Если смотреть в абсолютных цифрах, то для Read

для ReadE

Это все тонкости, но в hi-load системах такие тонкости имеют большое значение. Так что "код скомпилировался и выдает правильный результат" в ряде случаев далеко не все. Скорость работы, потребление ресурсов тоже имеют значение.

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

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

Затем работал, написал около 10000 строчек кода, отладил и что-то начал в этом понимать.

А потом оказалось, что на Clipper уже никто не пишет, dBase никому не нужен, а знания MACRO-11 с PDP-11 не особо помогают в TASM. Порядок операндов другой, автоинкрементной/автодекрементной адресации нет, да и половины привычных режимов работы с памятью просто не существует.

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

Например, поддерживал legacy систему в банке, или был куплен лицензионный Delphi 3, а за разработку на ворованном преследовали, приходилось сидеть на легальной копии. А потом снижение когнитивных функций, сенильная деменция и …

ну да, а вчера вышло сразу несколько обновлений LLM от ведущих игроков, сложно будет угнаться.

Но: если вы зададите вопрос на SO, также есть шанс, что вы

  • не получите внятный ответ совсем

  • получите дискуссию-холивар, ведущую внику

  • получите его через сутки-двое-трое-неделю

  • если вы что-то не поняли задали дополнительный вопрос - ждём ещё час-день-неделю. А задачки то горят...

Разговор с "ИИ" - это диалог в реальном времени. Спросили, не поняли, уточнили, подумали, задали ещё...

Сам пока не фанат генеративок как инструмента, но плюсы определённо присутствуют. Ну а любители скопипастить ответа не обдумывая и не читая комментарии что с SO, что с "ИИшкой" так сделают, не велика разница)

С ИИ вы получаете один вариант ответа. И никакой дискуссии

А мне qwen как раз тем и нравится, что можно выделить кусок ее ответа и подискутировать - попросить объяснить, переделать.

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

У меня есть пример, когда ИИ на вопрос "какой вариант кода эффективнее" дает ответ диаметрально противоположный правильному.

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

Буквально вчера увидел видео в котором идут похожие рассуждения

Там есть тейк про то, что на stackowerflow были сеньоры которые минусовали вопросы и говорили "иди разберись в теме, а не просто копируй код отсюда"
Также видосе приводятся примеры, когда нейронка отвечает также)))

Разница в том, что ИИ отвечает так сильно реже, чем сеньоры. Если каждый такой ответ заставляет человека идти разбираться, что тот кто раньше "кодил через stackoverflow" ходил разбираться чаще, чем тот кто сейчас "кодит через ИИ"

ну значит будут ии, которые будут минусить и писать - иди разбирайся в теме

И кто же их создаст? Тут нужен альтруист, который обрубит сук, на котором сидит.

Если бы был хоть какой-нибудь шанс на это — все создатели моделек сейчас бы хором кричали: «Это не ИИ, и даже близко нет, это Т9 из вашего кнопочного телефона на стероидах!».

это значит они не хотели обсуждать эти вопросы кстати

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

ох я разобравшись чутка в свинге без ии только что сам спросил у ИИ как сделать текстовый редактор и он даже чото написал, сейчас проверим )

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

*Примечание: копировать надо исходник из ответа, а не из вопроса

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

А ведь Eletron приложения появились без всяких LLM

это был первый всадник апокалипсиса

LLM -- второй

Вторым был LoCode/NoCode подход. LLM - это уже третий.

Добавил бы 5-м пунктом, что ИИ пишет потенциально опасный код, при этом случайным образом. Подтянуть deprecated-либу, которая при этом (что самое страшное) работает по крайней мере в данном конкретном случае для него обычное дело. И его не волнует, что она не поддерживается уже лет 10 и при любом последующем обновлении все, что на нее завязано, может накрыться медным тазом, не говоря уже про кучу уязвимостей, которые могут быть даже подробно описаны, но на которые ИИ опять же фиолетово.

Ну да, скопировать с интернета устаревший код раньше ведь было запрещено, как и создать этим пару UB.

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

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

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

Очень правильный тейк
Сейчас сформулирую и допишу в статью, спасибо

Давайте посмотрим на вопрос ретроспективно. В 2012 году появилась сверточная сеть AlexNet, погрешность работы - 16%. К 2015 году сети стали распознавать картинки лучше человека.

В 2014 году появилась первая GAN, которая генерировала картинки очень отдаленно напоминающие оригинал. К 2020 году появились диффузные модели и много чего еще, генерируемые картинки стали фотореалистичнами.

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

Видим что путь от первого появления до серьезного успеха - это 3-6 лет.

В 2017 году появился трансформер и первые сети способные генерировать тексты. До 2022 года это можно было считать бредогенераторами, и было нишевой историей. Никто тогда всерьез не думал, что это можно будет применить для написания программ.

Но появился gpt-3 и чат на его основе, оказалось что можно генерировать не только разговорные тексты, но и программный код.

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

Автор в статье указал на конкретные проблемы с применением ИИ в программировании на текущий день. Сам факт, что эти проблемы обозначены уже можно считать что они наполовину решены. Почему автор не писал об этих проблемах 5 лет назад? Потому что их невозможно было даже сформулировать.

Дальше вопрос техники. Посмотрите статьи на хабре о технологиях RAG, их пока не начали применять для генерации кода. В конечном итоге ИИ не обязательно генерировать код на человеческих языках программирования, для него это просто наборы токенов, но этими токенами со временем может стать машинный код. ЯПы придуманы для человека, машина может обходится и без ЯП. И когда это случится, куда тогда встроится сегодняшний программист, который ни то что с машинным кодом, даже с ассемблером уже не справится?

Посмотрите статьи на хабре о технологиях RAG, их пока не начали применять для генерации кода.

В ИИ редакторах кода (Cursor, Cline, etc) вовсю применяются векторные индексы кодовой базы, вполне себе RAG.

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

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

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

Разработчики, которые не могут выполнить те же задачи по коду, которые способен без ошибок делать GPT, и сейчас-то не особо востребованы)

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

К 2015 году сети стали распознавать картинки лучше человека.

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

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

Вы правда думаете, что люди не пробовали автоматически подставлять точки с запятой и вкрячивать нужные импорты? Вим так умел 25 лет назад, имакс, по-моему, тоже.

Да вот незадача: автоматически поставленная точка с запятой может полностью поломать flow, а импортированный модуль — оказаться не вашим, а модулем злоумышленника с таким же именем. Я даже смутно припоминаю какую-то атаку через удобный свинг-компонент в Netbeans (тогда — Forte), который заодно — когда видел недостающий импорт — вставлял что-то типа import com.sun.utils.Module, генерировал его на лету и все собиралось. На дворе стоял 2001 год.

Да с чего бы, пока что это всё вариации перцептронов, до думающего тут пропасть, а ресурсы уже кончаются.

Ну так ровно об этом я и говорю=) Насчёт ресурсов не знаю, как обычно, есть военка, где могут таинственно исчезать миллиарды долларов на инновационные проекты, включая ИИ, но именно что принципиального прорыва в этом вопросе не было очень давно, просто прокачка до предела существующих концепций

Ресурсы - это в смысле закон Мура встал. Пилить миллиарды долларов на коррупции это конечно не помешает, в этом смысле ресурсы будут еще долго =)

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

Подождите немного - и будет еще интереснее. ИИ научат машинному коду, и он будет выдавать сразу готовый бинарь, оптимизированный так, что никакой кожаный не в силах повторить или понять это. Программа не работает? Попроси Бога-Машину сделать так, чтобы работало. Знай заклинания и молитвы, промпт-инженер!

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

Это хороший case вы заметили. Я недавно искал замену одному алгоритму. Сначала результаты были правильные, но медленные. Через несколько итераций CharGPT предложил метод, который был похож на текущий, только переменные отличались. А ещё через несколько итераций произошла магия и я получил алгоритм, который работал «почти» правильно и в 5 раз быстрее. Я его немного допилил напильником, но там действительно есть пара строк, на которых держится это ускорение и я периодически вспоминаю о них, но никак не могу догнать, что они делают (обязательно разберусь, как будет время. Эта функция из хобби-проекта, так что потерпит).

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

Хотя был и такой случай - сформулировал задачу. В ответ - решений нет. Я спросил, откуда инфа? В ответ типа народ на форумах даже пишет, что ошибка в библиотеке. Но я вижу некоторые закономерности, что есть параметры, которым удаётся проскочить и получить корректный результат. В итоге нашёл решение, что если перед запуском библиотеки переставить исходные параметры в определенной конфигурации (что-то типа сортировки), то всё начинает работать как надо (В обычном режиме функцию запускали только один раз. Она ломалась на итерациях, но раньше этого не требовалось) Поэтому даже ответ, что решений нет, помогает немного сосредоточится и поискать рядом.

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

Нет, не будет. Разбивать задачу на этапы и слои абстракции для ИИ так же выгодно, как и для человека. Никто не будет убирать этап компиляции под конкретную архитектуру, потому что к задаче это не относится, а делать сразу две задачи ИИ может хуже, чем одну (алгоритм и оптимизация под железо).

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

который невозможно огреть хворостиной в сомнительных случаях

О, я кажется понял, что не так с удалёнкой…

ИИ пишет код, который решит проблемы сейчас, но создаст проблемы в будущем.

А люди-то беспроблемный код фигачат, ага.

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

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

А люди-то беспроблемный код фигачат, ага.

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

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

Нейронками нужно уметь пользоваться (как и любым инструментом)

Согласен с вами и пишу об этом в конце статьи, возможно вы чутка не дочитали ее)

Я часто повторяю: «Чтобы стать неплохим программистом, необходимо написать несколько десятков тысяч строк говнокода — и без сожаления выбросить его в мусорное ведро».

а сейчас можно с помощью ИИ склепать с десяток проектов и так ничего и не понять

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

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

Если программист справляется с задачами мидла или сеньора, то он мидл или сеньор по факту, даже если справляется он в связке с гпт. А костыли с багами накручивают и всякие матёрые зубры кодинга. Просто посмотрите на ченджлоги таких проектов как glibc или qt, я не думаю что их ламеры пишут.

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

а может не хочет общаться с ИИ ведь ИИ не серебрянная пуля можно посмотреть обсуждения людей и потыкаться с ошибками

Если программист справляется с задачами мидла или сеньора, то он мидл или сеньор по факту, даже если справляется он в связке с гпт.

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

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

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

ChatGPT точно не может писать код на уровне синьёра, и только в очень ограниченных случаях (суперпопулярный стек, тривиальная бизнес-логика) — на уровне мидла.

И я очень сильно сомневаюсь, что LLM когда-нибудь сможет. А другой технологии у них для нас пока нет.

и сделать выводы о том как писать код надо и как не надо

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

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

То есть опять же получается, что это какие-то сферические рассуждения в вакууме: вот программист А всё знает сам и оттого он выдаёт качественный код, а программист Б не всё знает сам и оттого не может выдать качественного кода априори. В реале же программист А может иметь в голове пачку диких представлений из 90-х годов, плодить ошибки работы с памятью (и не надо мне рассказывать, что хорошие программисты ошибок не допускают, это полная чепуха) и отказываться признавать, что его подходы неадекватны реальности. А программист Б может пользоваться нейронками и при этом внимательно анализировать, насколько получаемый код соответствует запросам по качеству.

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

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

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

Нейронка это по сути такой же кристаллизованный чужой опыт, что и книги

Нет. Разница принципиальная. Учить справочники инженеру не нужно было никогда - в голове у него опыт совершенно другого рода.

Ваше "классик vs prompt" — искусственная войнушка.

Вы представили ситуацию, как противостояние двух крайностей:

  • "Классические программисты" (якобы пуристы, отказывающиеся от ИИ)

  • "Prompt-инженеры" (якобы не думающие, полностью доверяющие ИИ)

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

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

Хороший разработчик сегодня:

  • Знает, где ИИ тащит, а где тормозит

  • Понимает, проверяет и точит генерируемый код

  • Использует ИИ не только для "напиши", но и для обучения, анализа, рефакторинга, документирования…

ИИ может как создавать технический долг (плохой код), так и уменьшать его (анализ и рефакторинг)

Ваше "классик vs prompt" — искусственная войнушка.

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

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

Согласен с вами и именно это я и пишу в конце статьи - именно так и нужно использовать ИИ

"Классик vs prompt" — остро, но притянуто. Реальность — не дуэль, а спектр: от осторожного юза ИИ для рутины до "выращивания" кода в диалоге про "что и зачем". Вы в конце называете его инструментом, но статья кричит "кто кого". Упрощение искажает суть, а суть — в трансформации ролей, а не в "кто победит". Реальная эволюция — во взаимодействии с инструментом, а не в его осуждении. Нужен системный взгляд на плюсы и минусы вместо "плохой код". Суть не в победе "классиков", а в том, как ИИ делает нас другими.

ИИ — не просто инструмент, а доступ к опыту тысяч разработчиков. Это мощная тема. Профессия идет от сольных героических концертов к диалогу с "коллективным опытом индустрии". Успех теперь не в том, чтобы знать больше всех, а в том, чтобы лучше всех вести эту беседу. Разработка уже про "что" и "зачем", а не про "я сам".

как я понял надо понять как разбить(мне это напоминает пошаговое наблюдения - наверно это и есть модульность или то что перед модульностью ) сложную задачку на подзадачки чтобы проще было контактировать с ИИ, соотв это еще структура кода, там сразу с напрыга это может быть нетривиально иногда, почти у каждой задачки в условиях ЯП есть около 3 решений, я испытал это воочию, на условно простой, вроде бы казалось задачке, а по итогу изза разбития на абстракции она стала совсем другой что в начале

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

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

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

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

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

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

проще и быстрее написать самому

Зависит от задач и навыков. Если умеешь декомпозировать и формулировать, ИИ ускоряет:

  1. Правильная модель: разные модели, разные стеки, разные результаты.

  2. Правильный контекст: не 'напиши мне X', а 'вот существующий код […], используемые паттерны […], создай компонент X, который будет интегрироваться в Y с учетом Z ограничений'.

  3. Правильная декомпозиция: если задачу нельзя четко объяснить в 2-3 абзацах, она слишком велика для одного запроса.

  4. Правильные итерации: качество результата пропорционально качеству вашего диалога с ИИ.

  5. Правильные ожидания: ИИ в разработке — не идеально, но практически полезно при правильном подходе.

Сразу оговорюсь, ИИ бесполезен для 5% критических задач. Но для базового кода, что закрывает остальное, думающий разработчик с ИИ эффективнее "классика". Без подхода — да, проще самому.

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

Пример таковой гипотезы можно? Потому что мне все еще кажется, что профессионал оценит гипотезу примерно в триста раз лучше (и быстрее).

Пока все примеры, что я видел выглядели так: Я взял технологию Х, в которой я полный 0 и наваял какой там сервис. И надо же - он заработал

Да, я тоже. При этом технология должна быть максимально популярной и простой, как табурет.

Потому и спросил.

Я взял технологию Х, в которой я полный 0 и наваял какой там сервис.

Это называется helloworld.

И надо же - он заработал

Если в него получится вносить изменения - прекрасно. Если получится.

Да всё что угодно, любой глупый аопрос,за который любой кожаный тебя пошлет. Что нить в духе "а почему фотон не твердый?" Раньше такое можно было спросить только у очень близких и пьяных друзей.

Классический программист сталкиваясь с очередной проблемой проводил многочасовые дебаг сессии

Это классический постсоветский программист так делает. Потому что Аджарии, «фигак-фигак и в продакшн», сдаем фичи, а через неделю вносим их же в техдолг. Хотя можно было потратить несколько больше времени на проектирование или вместо дебага заняться рефакторингом.

Вопрос старый. У ДеМарко в «Дедлайн» в паре глав рассматривается

Причем тут "постсоветский"? Аджайлы с фигак-фигак - более позднее явление, в нём даже дебажить много часов разучились, что уж там о проектировании.

Вы правильно поняли мой комментарий, хотя в «печатном» варианте (по сравнению с родившимся в мозгу) из него выпали некоторые фразы.

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

ИИ также обладает этим умением и обладает им в значительной степени больше, чем человек

Вот сейчас смешно было.

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

Согласен, ИИ пишет сносно — дай ему контекст: код, архитектуру, стек, задачу. Не про те условных 5% задач, где ошибка фатальна, а про базовый код, что закрывает 95%. Думающий разработчик с ИИ эффективнее коллеги без него. Проблема не в ИИ, а в подходе.

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

Может я пользовался не теми моделями, но сложные ошибки, на которые требуют "многочасовые дебаг сессии" нейросети все еще не могут отладить, и все приходится решать самому. Сейчас gpt поможет отладить твой код, только если там прямо сильно глупая ошибка, которую ты бы и так нашел на stackoveflow.

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

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

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

Из чего состоит работа программиста? Пришёл на работу, открыл борду, выбрал таску по приорити, обновил репо, открыл иде, понял что надо сделать, подумал как, выбрал вариант, запустил, не работает, ресерчишь, выясняешь что по неподвластным тебе причинами вариант не рабочий, вспоминаешь другие, повторяешь пока не заработает, поднимаешь ПР, ревьювишь, мерджишь, отдаёшь в QA. Звучит как рутина, и так оно и есть, и таких рутин бесконечное количество, люди генерируют их на лету, с рождения. А то что сейчас умеет делать ЛЛМ, это в ~9X% случаев понимать рутину и следовать ей.

Для замены людей нужно нечто большее чем ЛЛМ, например модели обученные программировать на реальных программистах програмирующих в специальных лабораториях. Рантаймы которые обеспечят удобный для ИИ полный цикл, включая инфраструктуру, тесты, бизнес анализ, безопасность, масштабируемость, итд.

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

Исходя из вашей логики, эффективная посудомоечная машина должна выглядеть как робот с двумя руками/глазами натренированная на рутине профессиональных мойщиках посуды в лабораторных условиях.
Но в реальности мы видим, что коробка с ТЭНом и насосами работает в 99% случаев эффективнее.

Так и с ИИ, представьте, что фулл-тайм нейронке-программисту даже не нужно будет приходить на работу и что-то открывать. Она 24/7 работает с кодом: пишет, рефакторит, тестирует, рефакторит, меняет подход, меняет температуры ответов, мержит, тестирует, мержит, тестирует, внедряет.
А программисты-архитекторы и продукт менеджеры приходят утром, смотрят на графики, цифры, эффективность и ставят новые задачи, иногда подкручивают параметры ИИ.

P.s. Ну и если эта нейронка-программист локальная, то еще меняют видеокарты и сдувают пыль:)

Она 24/7 работает с кодом: пишет, рефакторит, тестирует, […]

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

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

Я попросил у chatgpt, gemini, claude, deepseek, lechat, github copilot написать инициализацию дисплея для lvgl и esp lvgl port, никто не справился ни с какой попытки, и честно скажу что меня это радует

#include
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "esp_err.h"
#include "esp_log.h"

#include "lvgl.h"

static const char *TAG = "lvgl_display";

// Настройки дисплея - настройте под ваш дисплей
#define LCD_PIXEL_CLOCK_HZ (20 1000 1000)
#define LCD_WIDTH 240
#define LCD_HEIGHT 320

// Настройки пинов SPI - настройте под вашу схему подключения
#define LCD_SPI_HOST SPI2_HOST
#define LCD_MOSI_GPIO 23
#define LCD_MISO_GPIO -1 // -1 если не используется
#define LCD_SCLK_GPIO 18
#define LCD_CS_GPIO 5
#define LCD_DC_GPIO 19
#define LCD_RESET_GPIO 15
#define LCD_BL_GPIO 4 // Управление подсветкой (если есть)

// Данные для драйвера LVGL
static lv_disp_draw_buf_t disp_buf; // Буфер отрисовки
static lv_disp_drv_t disp_drv; // Драйвер дисплея
static lv_color_t buf1 = NULL; // Буфер 1
static lv_color_t
buf2 = NULL; // Буфер 2 (опционально)
static esp_lcd_panel_handle_t panel_handle = NULL;

// Функция обновления дисплея для LVGL
static void lvgl_flush_cb(lv_disp_drv_t drv, const lv_area_t area, lv_color_t *color_map)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
int offsetx1 = area->x1;
int offsetx2 = area->x2;
int offsety1 = area->y1;
int offsety2 = area->y2;

// Передаем буфер с изображением на дисплей
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
lv_disp_flush_ready(drv);

}

// Задача для обновления LVGL
static void lvgl_task(void *pvParameter)
{
while (1) {
vTaskDelay(pdMS_TO_TICKS(10));

    // Вызов обработчика задач LVGL
    lv_task_handler();
}

}

// Настройка подсветки дисплея (если есть)
static void backlight_init(void)
{
gpio_config_t bk_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << LCD_BL_GPIO
};
ESP_ERROR_CHECK(gpio_config(&bk_gpio_config));
gpio_set_level(LCD_BL_GPIO, 1); // Включаем подсветку
}

// Инициализация LVGL
static void lvgl_init(void)
{
lv_init();

// Выделяем память для буферов отрисовки
size_t buf_size = LCD_WIDTH * 20 * sizeof(lv_color_t); // Буфер на 20 строк
buf1 = heap_caps_malloc(buf_size, MALLOC_CAP_DMA);
assert(buf1);
buf2 = NULL; // Можно выделить второй буфер для двойной буферизации

// Инициализация буфера отрисовки
lv_disp_draw_buf_init(&amp;disp_buf, buf1, buf2, LCD_WIDTH * 20);

// Инициализация и регистрация драйвера дисплея
lv_disp_drv_init(&amp;disp_drv);
disp_drv.hor_res = LCD_WIDTH;
disp_drv.ver_res = LCD_HEIGHT;
disp_drv.flush_cb = lvgl_flush_cb;
disp_drv.draw_buf = &amp;disp_buf;
disp_drv.user_data = panel_handle;
lv_disp_drv_register(&amp;disp_drv);

// Создаем задачу для обработки LVGL
xTaskCreate(lvgl_task, "lvgl", 4096, NULL, 5, NULL);

ESP_LOGI(TAG, "LVGL инициализирован успешно");

}

// Инициализация LCD панели
static void lcd_panel_init(void)
{
ESP_LOGI(TAG, "Инициализация SPI интерфейса для LCD");

spi_bus_config_t buscfg = {
    .sclk_io_num = LCD_SCLK_GPIO,
    .mosi_io_num = LCD_MOSI_GPIO,
    .miso_io_num = LCD_MISO_GPIO,
    .quadwp_io_num = -1,
    .quadhd_io_num = -1,
    .max_transfer_sz = LCD_WIDTH * 80 * sizeof(uint16_t),
};

// Инициализация SPI шины
ESP_ERROR_CHECK(spi_bus_initialize(LCD_SPI_HOST, &amp;buscfg, SPI_DMA_CH_AUTO));

esp_lcd_panel_io_spi_config_t io_config = {
    .dc_gpio_num = LCD_DC_GPIO,
    .cs_gpio_num = LCD_CS_GPIO,
    .pclk_hz = LCD_PIXEL_CLOCK_HZ,
    .lcd_cmd_bits = 8,
    .lcd_param_bits = 8,
    .spi_mode = 0,
    .trans_queue_depth = 10,
};

// Настройка интерфейса SPI для панели
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_SPI_HOST, &amp;io_config, &amp;panel_handle));

// Настройка GPIO для сброса LCD (если используется)
if (LCD_RESET_GPIO &gt;= 0) {
    gpio_config_t reset_gpio_config = {
        .mode = GPIO_MODE_OUTPUT,
        .pin_bit_mask = 1ULL &lt;&lt; LCD_RESET_GPIO
    };
    ESP_ERROR_CHECK(gpio_config(&amp;reset_gpio_config));
}

// Сброс дисплея
if (LCD_RESET_GPIO &gt;= 0) {
    gpio_set_level(LCD_RESET_GPIO, 0);
    vTaskDelay(pdMS_TO_TICKS(100));
    gpio_set_level(LCD_RESET_GPIO, 1);
    vTaskDelay(pdMS_TO_TICKS(100));
}

// Настройка устройства LCD - укажите корректный драйвер для вашего дисплея
// Это пример для ILI9341
esp_lcd_panel_dev_config_t panel_config = {
    .reset_gpio_num = LCD_RESET_GPIO,
    .color_space = ESP_LCD_COLOR_SPACE_RGB,
    .bits_per_pixel = 16,
};

// Выберите подходящий драйвер для вашего дисплея
// Например, для ILI9341:
// ESP_ERROR_CHECK(esp_lcd_new_panel_ili9341(panel_handle, &amp;panel_config, &amp;panel_handle));

// Или для ST7789:
ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(panel_handle, &amp;panel_config, &amp;panel_handle));

// Инициализация панели
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));

// Специфичные настройки для конкретной модели дисплея
// Раскомментируйте и настройте в соответствии с вашим дисплеем
// ESP_ERROR_CHECK(esp_lcd_panel_invert_color(panel_handle, true));
ESP_ERROR_CHECK(esp_lcd_panel_set_gap(panel_handle, 0, 0));
ESP_ERROR_CHECK(esp_lcd_panel_swap_xy(panel_handle, true));  // Поворот экрана, если нужно
ESP_ERROR_CHECK(esp_lcd_panel_mirror(panel_handle, false, true)); // Зеркалирование, если нужно

// Включение дисплея
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));

}

// Основная функция инициализации дисплея
void display_init(void)
{
// Инициализация LCD панели
lcd_panel_init();

// Инициализация подсветки
backlight_init();

// Инициализация LVGL
lvgl_init();

ESP_LOGI(TAG, "Дисплей и LVGL инициализированы успешно");

}

// Пример использования в app_main
void app_main(void)
{
// Инициализация дисплея
display_init();

// Создание простого интерфейса для теста
lv_obj_t *label = lv_label_create(lv_scr_act());
lv_label_set_text(label, "LVGL на ESP32");
lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);

while (1) {
    vTaskDelay(pdMS_TO_TICKS(1000));
}

}

#include "lvgl.h"
#include "lvgl_helpers.h"
#include "lvgl_port.h"

// Настройка дисплея
static lv_disp_buf_t disp_buf;
static lv_color_t buf[LV_HOR_RES_MAX * LV_VER_RES_MAX];

void lvgl_init(void) {
// Инициализация буфера дисплея
lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * LV_VER_RES_MAX);

// Настройка дисплея
lv_disp_drv_t disp_drv;
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = LV_HOR_RES_MAX; // Горизонтальное разрешение
disp_drv.ver_res = LV_VER_RES_MAX; // Вертикальное разрешение
disp_drv.buffer = &disp_buf;
disp_drv.flush_cb = disp_flush; // Функция для обновления дисплея
lv_disp_drv_register(&disp_drv);

// Инициализация LVGL
lv_init();

}

// Функция для обновления дисплея
void disp_flush(lv_disp_drv_t disp_drv, const lv_area_t area, lv_color_t *color_p) {
// Обновление дисплея
// Вставьте код для обновления дисплея здесь
// Например, для SPI TFT дисплея:
// spi_tft_write_area(area->x1, area->y1, area->x2, area->y2, color_p);
}

int main(void) {
// Инициализация дисплея
lvgl_init();

// Создание экрана
lv_obj_t *scr = lv_obj_create(NULL);
lv_disp_load_scr(scr);

// Создание объектов на экране
lv_obj_t *label = lv_label_create(scr);
lv_label_set_text(label, "Hello, World!");
lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);

while (1) {
    lv_task_handler();
    delay(5);
}

return 0;

}

такое они и выдают, но это не работает, при компиляции весь код становится красным

Если бы код был на питоне, то не было бы ошибок компиляции)

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

Я взял библиотеку дисплея, изменил её для работы с lvgl и это оказалось проще

вот как раз появлении хороших агентов программирования уменьшит потребность в open source, проще будет попросить сгенерить подходящее решение под себя, чем искать, скачивать, адаптировать стороннее.

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

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

Проблема не в UI/UX, а в тебе — мышлении и подходе. Желание копать глубже не зависит от лопаты.

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

эволюция UI/UX это возврат к понятию всё есть файл, и использовать текстовые буфферы ) всё просто - просто текстовые буфферы лучше работают с текстом )

Заголовок сразу бредов - не будет такого никогда.

Все же непонятно как работодателю теперь нанимать программистов. Т.е. вот есть один который имеет отличные технические навыки, но не слышал-не использовал Курсор(ну или что-то подобное). И другой, где навыки поменьше, но который активно внедряет LLM в свою работу, выдавая к примеру 80% кода от LLM.

Кто в этом случае будет приносить большую пользу компании

"Большая польза" — это про скорость, качество или что-то еще?

Брать того, кто имеет отличные технические навыки И умеет эффективно использовать cursor. Все просто. Cursor - это инструмент, такой же технический навык. Как рычаг. Кто его не использует, просто сам себе злобный буратина - «взял билет и не поехал». Потом, к хорошему быстро привыкаешь.

В задачах чуть сложнее джейсоноукладки — LLM до сих пор не помощник.

Бесит что LLM не может сказать что реально а что ему только кажется, что есть в книге а что он узнал из агенства ОБС, не может составить непротиворечивую картину. В результате непрекращающиеся глюки и полная неспособность обосновать свое решение. У архитектора это главная задача и она не решена.

Бесит что LLM не может сказать что реально а что ему только кажется

Бесит, что на техническом (вроде бы) ресурсе пользователи не понимают, как работают LLM и на серьезных щах задвигают про "LLM думает" и "LLM кажется"

Мне не важно что там у него за требуха внутри.

ИИ не проблема, подход — да. Классикам ИИ — как чайке ключ.

Кризис диджитал перепроизводства нас ждёт...

КМК для кодинга с использованием ИИ обычные промпты недостаточно эффективны, надо создать некий метаязык и уже его скармливать специально заточенным под это моделям. Сами сетки очень недурственны в генерации кода, главная проблема состоит в том, чтобы дать им понять что ты от них КОНКРЕТНО хочешь. =)

А знаете, как называется язык для формально точных описаний, чего хочешь?

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

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

Бизнес теряет деньги. Бизнес потеряет деньги.

извините, но мне показалось забавным, как автор зациклился на этой фразе)

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

Sign up to leave a comment.

Articles