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

Все приведенные ниже примеры, скрины и сочетания клавиш рассматриваются в средах разработки от Jetbrains на платформе Intellij.

Но почему именно Intellij?

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

Оглавление:

  1. Встроенный единый список всех функций, языковых конструкций и операторов языка с Drag-n-Drop.

  2. Быстрое выполнение произвольного фрагмента кода/выражения из проекта прямо в редакторе, либо в отдельном окне - REPL GUI

  3. Поддержка вложенного предпросмотра кода функций/методов/классов и т.д.

  4. Поддержка вложенного поиска мест использования функций/методов/классов и т.д

  5. SQL - графический интерфейс для операций чтения (в том числе JOIN и GROUP-BY HAVING)

  6. Выводить неочевидные фичи в контекстном меню отдельным пунктом

  7. Навигация по коду с учетом наследования классов ООП

  8. Раздельные цвета для встроенных и пользовательских функций/методов/классов и т.д.

  9. Встроенная документация для операторов и языковых конструкций

1. Встроенный единый список всех функций, языковых конструкций и операторов языка с Drag-n-Drop.

Итак, вы хотите попробовать написать программу на языке, с которым никогда не работали. И вот вы установили IDE для работы с ним, открыли его, создали проект, а что дальше? А дальше ничего, ведь никаких функций, языковых конструкций, и операторов данного языка вы не знаете, и свою первую программу вам будет буквально не из чего писать. В итоге вам придется будет пойти в гугл, искать мануалы и справочники, изучать их. Уже на этом этапе вы скорее всего развернетесь и уйдете, если не готовы выделить на это время. К тому же нет гарантии, что вы их быстро найдете, а тогда вы и вовсе сделаете вывод, что их нет. Но все могло быть по другому, будь в IDE встроенный единый структурированный древовидный список функций, языковых конструкций и операторов, распределенных по разделам (к примеру для функций - функции для работы с массивами, функции для работы со строками и т.д). Откуда можно было бы Drag-n-Drop'ом перетащить интересующие вас в файл. Вам бы ничего не пришлось искать, так как все что есть в языке, было бы у вас перед глазами сразу. Точно также вы бы не допустили синтаксическую ошибку, потому что вам не пришлось бы писать вызов функции вручную.

Drag-n-Drop функций/классов из списка
Drag-n-Drop функций/классов из списка
Для этих целей автодополнение не подойдет, поскольку для него как минимум нужно ввести первую букву класса/функции. То есть придется будет перебирать все 26 букв английского алфавита. В тоже время выдача автодополнения никак не структурирована, а вышеупомянутый список будет делать группировку по разделам. Например, функции для работы со строками, затем функции для работы с массивами и т.д. Drag-n-Drop языковых конструкций из списка
Drag-n-Drop языковых конструкций из списка
Drag-n-Drop операторов из списка
Drag-n-Drop операторов из списка

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

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

2. Быстрое выполнение произвольного фрагмента кода/выражения из проекта прямо в редакторе, либо в отдельном окне - REPL GUI

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

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

Быстрое выполнение выражений из куска кода
Быстрое выполнение выражений из куска кода

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

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

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

$year = (new DateTime('18.01.2101'))
        ->sub((new DateTime('01.01.2024'))->diff(new DateTime('01.02.2024')))
        ->format('Y');

if ((($year % 4 == 0) && ($year % 100 != 0)) || ($year % 400 == 0)) {
    echo "Полученный год является високосным\n";
} else {
    echo "Полученный год не является високосным\n";
}

На все том же onlinegdb.com (по данной ссылке язык php будет выбран автоматически) вы можете попробовать получить результаты выражений из него, чтобы понять, насколько это неудобно без быстрого выполнения кода. Учтите, что выражения нужно будет оборачивать в echo или var_dump. Echo - если результат выражения - число или строка, например, echo 123;, echo "abc";; var_dump - если все остальное, например - var_dump(false);, var_dump(array(1,2,3); .

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

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

3. Поддержка вложенного предпросмотра кода функций/методов/классов и т.д.

Но что, если вы хотите не выполнить вызываемую в данном месте функцию, а просто посмотреть ее код? Конечно, вы сможете открыть его в новой вкладке, но если вкладок много, то вы почувствуете, что открывать еще одну уже "некуда". Скорее всего вы не раз с этим сталкивались в браузере. В качестве решения этой проблемы можно открыть не вкладку, а быстрый предпросмотр определения (Quick Definition, Ctrl+I), однако если там внутри будет тоже функция, которую вы захотите посмотреть, то все равно придется открывать новую вкладку, ведь вложенный предпросмотр сейчас не поддерживается. Наверняка вас это просто остановит, ничего открывать вы не станете, а просто развернетесь и уйдете, так и не получив ответ на свой вопрос. А если бы был вложенный предпросмотр, то вы бы смогли "провалиться внутрь" столько раз, сколько вам нужно, и ответ на вопрос был бы получен.

То, как это придется делать сейчас:

И вот как это должно быть:

И никаких лишних вкладок
И никаких лишних вкладок

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

Описанный кейс чем-то напоминает этот мем из начала десятых:

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

4. Поддержка вложенного поиска мест использования функций/методов/классов и т.д

Тоже самое, что пункт 3, но в обратном направлении. Если вы хотите посмотреть, где вызывается функция, в которой вы сейчас находитесь, то для этого можете вызвать Show Usages (Ctrl+Alt+F7), и появится окно со списком таких мест и их содержимым. Однако если вы захотите уже оттуда повторить тоже самое, то у вас это не получится, и снова все будет упираться в необходимость открыть новую вкладку. Чего делать вы конечно же не станете, из-за чего вы снова не сможете получить ответ на свой вопрос и снова уйдете. И снова поддержка вложенности для данного функционала могла бы решить эту проблему

Как это приходится делать сейчас:

И вот как это должно быть:

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

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

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

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

5. SQL - графический интерфейс для операций чтения (в том числе JOIN и GROUP-BY HAVING

Казалось бы, п.1 (единый список, в данном случае операций) и п.2 (быстрое выполнение выражений) уже должны будут сильно упростить изучение языка SQL, но ведь можно пойти дальше, и вовсе выполнять SQL запросы без необходимости их написания, нажатием пары кнопок. Частично это уже реализовано - при открытии в IDE Datagrip (функционал которой также встроен в другие IDE линейки Intellij) какой-нибудь таблицы, выполняется запрос SELECT к базе данных. Также можно добавлять фильтр и сортировку - в итоге к запросу добавляется WHERE и ORDER BY.

Однако что касается JOIN и GROUP BY, то такой возможности пока нет, и запросы с данными операторами нужно будет писать самому. Но это тоже можно было бы реализовать в графическом интерфейсе, путем выбора таблиц, которых нужно присоединить друг к другу, и выбора полей, по которым должны быть присоединение. Ну и возможность выбора полей для группировки.

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

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

6. Выводить неочевидные фичи в контекстном меню отдельным пунктом

Каким образом вы узнаете о возможностях программы, в которой находитесь впервые? Обычно большинство людей это делает через вызов контекстного меню нажатием правой кнопки мыши, и смотрит, что там есть. И делает выводы, а если чего-то там нет - значит в этой программе этого нет и быть не может. Вот только сейчас в IDE это работает не так. Здесь у вас в контекстном меню отображаются далеко не все доступные фичи в данном месте (место, где был курсор, на то меню и контекстное). А среди них есть много важных, но вы о них даже и не узнаете, либо узнаете по случайности. Именно поэтому сейчас нужны месяцы, на то чтобы освоиться в IDE.

В качестве примера функций, которых сейчас нету в контекстном меню, можно привести фичи, описанные в п.3 (быстрый просмотр кода функции) и в п.4 (поиск использований функции) в их текущем виде, навигация вперед/назад, или например, отображение параметров, принимаемых функцией, при нажатии Ctrl+P:

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

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

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

7. Навигация по коду с учетом наследования классов ООП

Сейчас навигация в IDE тоже происходит с учетом объектно-ориентированного программирования, но далеко не всегда. Вот к примеру родительский и дочерний класс, наследуемый от него:

Чему будет равно $childClass->one() ? Давайте доверимся навигации IDE, и посмотрим, куда она нас приведет:

Итак, если верить IDE, ответ будет 444. Однако это неправильно, и правильным ответом будет 555. Потому что метод three() переопределяется в дочернем классе, и результат нужно брать оттуда. То есть навигация должна была выглядеть вот так:

Но почему IDE привело нас в three() родительского класса? Потому что как только вы перешли из дочернего класса в родительский, IDE забыло, где вы были до этого, и делало навигацию так, как будто вы и не были там. Если бы вы например переходили бы из метода $parentClass->one();, то такая навигация была бы верна.

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

8. Раздельные цвета для встроенных и пользовательских функций/методов/классов и т.д.

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

Непонятно, да? А все потому что они окрашены одним цветом.

Ответ

array_find является частью текущего проекта, а array_search - встроенной функцией php:

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

9. Встроенная документация для операторов и языковых конструкций

Если вы в IDE наведете курсор на нативную функцию/класс языка программирования, то появится всплывающее окно с объяснением, что это такое и зачем нужно. И вам не придется будет лезть в гугл, чтобы это выяснить.

Однако с языковыми конструкциями и операторами так уже не прокатит - для них это сейчас не реализовано. Вот например, выражение из куска кода php из пункта 2:
(($year % 4 == 0) && ($year % 100 != 0)) || ($year % 400 == 0)
Что означают например && и || ? Это операторы логического И и логического ИЛИ. Но если бы я сейчас об этом не написал, а вы допустим этого не знаете, то как минимум вам бы пришлось пойти в гугл, чтобы узнать это. Но даже если и знаете, то не обольщайтесь - одни и те же операторы могут выполнять разные действия в разных языках. К примеру, результатом выражения $var1 || $var2  в php будет true/false, а в js - значение переменной var1 или var2, в зависимости от того, является ли пустой первая переменная.

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

Заключение.

Вот мы и разобрали фичи будущего, которые устранят основные причины, препятствующие вам прямо сейчас взять и начать программировать на произвольном языке. Но когда они все будут реализованы? А это уже зависит от компании Jetbrains, и (внезапно) от вас всех тоже. Дело в том, что Jetbrains (как и другие компании) при реализации новых фич расставляет приоритеты исходя из того, на что есть запрос пользователей. Выясняют они наличие этого запроса через свой баг-трекер youtrack, где смотрят на количество голосов за тот или иной feature request. На все описанные тут фичи тоже заведены тикеты, и ссылки на них упомянуты в соответствующих пунктах данной статьи. Однако запроса пользователей на данный функционал не было, так что реализованы они будут не скоро. Возможно, что не раньше, чем через 10-15 лет. Сейчас еще не начата реализация ни одной из них.

Но если вы хотите приблизить их реализацию, то можете пройти по ссылкам и проголосовать. Авторизоваться в трекере можно через аккаунт Google. Но если есть аккаунт Jetbrains, то лучше через него (также можно через Github или Bitbucket). Если на фичах наберется достаточное число голосов, и они выйдут в топ (для этого нужно около 500 голосов), то скорее всего сразу с этого момента будет начата реализация. Сколько времени на нее уйдет, сказать сложно, но если поставят повышенный приоритет, то возможно что и меньше года уйдет на большинство из них.

Ссылки на тикеты, если вы не хотите их искать по статье
  1. Встроенный единый раскрывающийся список функций, языковых конструкций и операторов - ссылка на тикет
    1.1 Выполнение функций/методов/классов отдельном окне - ссылка на тикет

  2. Быстрое выполнение кода прямо в редакторе, либо с копированием в отдельное окно - REPL GUI - ссылка на тикет
    2.1 Cистема хранения и генерации примеров переменных - ссылка на тикет

  3. Вложенный предпросмотр кода функции/метода/класса - ссылка на тикет

  4. Вложенный поиск мест использования функций/методов/классов - ссылка на тикет

  5. Графический интерфейс для операций JOIN и GROUP BY в SQL - ссылка на тикет

  6. Вывод неочевидных фич, доступных в месте клика, в контекстное меню с помощью отдельного пункта - ссылка на тикет
    6.1 Страница с описанием неочевидных фич, доступных в месте вызова меню - ссылка на тикет

  7. Навигация по коду с учетом наследования классов ООП - ссылка на тикет

  8. Раздельные цвета для встроенных и пользовательских функций/классов и т.д. - ссылка на тикет

  9. Встроенная документация языковых конструкций и операторов - ссылка на тикет

Комментарии (82)


  1. talraaash
    03.10.2024 16:14
    +7

     Откуда можно было бы Drag-n-Drop'ом перетащить интересующие вас в файл.

    Как не читая документацию понять, что тебе нужна эта функция, которую ты перетащил мышкой в редактор?

    Или просто кусок кода из интернета.

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

    Но есть небольшой нюанс в таком подходе)


    1. a43mx Автор
      03.10.2024 16:14

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


      1. saboteur_kiev
        03.10.2024 16:14
        +17

        В большинстве случаев сейчас нужны не ключевые операторы, они реально несложные, а работа с библиотеками, или вообще запросы на какие-то API

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

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


        1. a43mx Автор
          03.10.2024 16:14

          Так эти фичи выполнения кода, показанные в гифке, это изначально фичи отладки - Quick Evaluate Expression, и Evaluate Expression (выполнение в отдельном окне). Они и в отладке довольно полезны, но там они предназначены для выполнения в контексте точки останова, и в радиусе нескольких строк от нее.

          Просто с отладкой есть сложности, начиная с того что ее может быть сложно настроить (тот же Xdebug языка Php), и заканчивая тем, что не всегда можно быстро воспроизвести сценарий, при котором будет достигнута точка останова.

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

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


      1. talraaash
        03.10.2024 16:14

        Нейминг далеко не всегда очевиден. В итоге, нужно найти в списке функцию, во всплывающем окне прочесть часть документации, чтобы убедится - это то что нужно. Не проще и быстрее сразу в полной документации использовать поиск? Зачем drag and drop?


        1. tempick
          03.10.2024 16:14

          Нейминг далеко не всегда очевиден

          Особенно в моем любимом php. За шесть лет работы так и не удалось запомнить названия многих встроенных функций для работы со строками. Хотя, я и не пытался) php.net в помощь всегда


          1. sberoneshot
            03.10.2024 16:14
            +8

            Welsh or C library function?

            mbsrtowcs, rhowch, strxfrm, cwtch, mwyn, wcstold, wcsoll, wmffre

            Ответы
            • mbsrtowcs - C

            • rhowch - Welsh (давать)

            • strxfrm - C

            • cwtch - Welsh (обнимать)

            • mwyn - Welsh (руда)

            • wcstold - C

            • wcsoll - C

            • wmffre - Welsh (имя: [Хэмфри])


        1. a43mx Автор
          03.10.2024 16:14

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

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

          Drag-n-Drop нужен не сам по себе, на гифке он был в связке с Live Template. Что нужно было для того, чтобы не писать вручную и избежать синтаксических ошибок


          1. artptr86
            03.10.2024 16:14

            Вот список всех классов в стандартной библиотеке Java SE 10: https://docs.oracle.com/javase/10/docs/api/allclasses-noframe.html Их примерно 6000. Как этот список кому-то поможет освоиться? А если по иерархии разложить, то и в документации, и в IDE это уже есть. И это ещё только классы без методов.


            1. a43mx Автор
              03.10.2024 16:14

              Понятное дело что он должен быть разложен по иерархии, иначе от него толку не будет. А насчет того, чтобы это было в IDE, такого не видел. Ну если вы не имели ввиду пакет Java OpenJDK, который и использовался для гифок. Но это просто пакет из папок и файлов, где дополнительно отображаются классы и функции из этих самых файлов. Специально туда никто не полезет ради этого. И это именно в Java так, в других языках по другому.

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

              На php.net к примеру список тоже есть, но опять же он там находится в неочевидном месте, и тоже нужно знать с чего начать. А даже если его и найти, то по нему еще и не вдруг поймешь, что это он - вот страница с ним

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


              1. artptr86
                03.10.2024 16:14

                Я про это говорю:

                Оно есть в IDE для джавы уже больше 20 лет. Аналогичная иерархия есть в IDE для дотнета, и в Rider, и в Visual Studio.


                1. a43mx Автор
                  03.10.2024 16:14

                  А в php/js такого нет. И наверняка не только в них. То есть единым стандартом это не является. И это просто исходники, папки с файлами. Которые предназначены для другого (как я понимаю, это видимо stubs для быстрой документации и автодополнения, которые в том же php накиданы линейно по файлам). Может и можно этим списком пользоваться для того чтобы сориентироваться, но с натяжкой. Потому что он на это не заточен


                  1. artptr86
                    03.10.2024 16:14

                    Которые предназначены для другого (как я понимаю, это видимо stubs для быстрой документации и автодополнения

                    что?


                    1. a43mx Автор
                      03.10.2024 16:14

                      stubs - это заглушки. Тут я ошибся, потому что в Java это вообще исходники, но например в php для встроенных функций есть отдельные файлы заглушки, которые содержат функции без тела, но с описанием в /** */. И вот эти файлы-заглушки нужны чисто чтобы была быстрая документация и автодополнение

                      В php просто нету такого, чтобы встроенные стандартные функции были тоже на php написаны


                      1. artptr86
                        03.10.2024 16:14

                        Так и для JS вы не построите список классов и функций. Нужны описания типов от TypeScript.


                      1. a43mx Автор
                        03.10.2024 16:14

                        На Typescript и сейчас все stubs-ы написаны, насколько я знаю


                      1. artptr86
                        03.10.2024 16:14

                        Я про это и говорю. Но то, что вы пытаетесь все языки объяснить терминологией php — неправильно.


        1. a43mx Автор
          03.10.2024 16:14

          Не проще и быстрее сразу в полной документации использовать поиск?

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

          Зачем drag and drop?

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


          1. artptr86
            03.10.2024 16:14
            +1

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

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


            1. a43mx Автор
              03.10.2024 16:14

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

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


              1. artptr86
                03.10.2024 16:14

                То, что человек будет знать о функции, не означает, что он будет использовать её правильно. С этой точки зрения написать комментарий для ИИ: «Сделай вот тут мне такое» даст больше эффекта.


        1. a43mx Автор
          03.10.2024 16:14

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

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


          1. artptr86
            03.10.2024 16:14

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


  1. RodionGork
    03.10.2024 16:14
    +15

    Кажется тут довольно однообразное представление о языках. Освоить Scheme с его скобочками, Erlang в котором нет ни переменных ни циклов, Assembler безо всяких if-else-ов или Haskell с его монадами и IO-типами... Сомнительно. Да что там - если вы впервые смотрите на селект для каналов в Go, если для вас невдомёк что такое мьютекс - вас весь JetBrains за один день ничему не научит. Всё-таки слишком броское название, не кажется оправданным.


    1. a43mx Автор
      03.10.2024 16:14

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

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

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


      1. RodionGork
        03.10.2024 16:14
        +7

        ну получается статья о том "как освоить любой язык похожий на те с которыми вы уже и так знакомы" :)

        думаю Вам будет хорошо ненадолго отложить PHP и продукты JetBrains и расширить кругозор в этих самых любых языках :)


        1. a43mx Автор
          03.10.2024 16:14

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


          1. RodionGork
            03.10.2024 16:14
            +5

            востребованные языки рождаются программистами которые знают много невостребованных, как-то так :)


          1. saidelman
            03.10.2024 16:14
            +1

            Выше привели пример каналов в го, для него есть продукт от InteliJ
            Ещё есть раст, для него тоже есть IDE (вроде бы ещё в бете). Или для си. Я бы не рискнул утверждать, что со всеми фичами из статьи можно научиться работать с этими языками.


      1. vadimr
        03.10.2024 16:14
        +3

        Если вы за день сможете хотя бы, например, понять семантику функции call/cc языка Scheme (не говоря о том, чтобы её научиться применять по делу), то это будет крайне удивительно. А синтаксис Scheme простой: слова в круглых скобочках.

        Кстати, именно Scheme иногда полезно преподавать в качестве первого языка программирования, чтобы не отвлекаться от содержательных вопросов на синтаксис и вот это всё, о чём статья.


        1. Kergan88
          03.10.2024 16:14

          >Если вы за день сможете хотя бы, например, понять семантику функции call/cc языка Scheme

          Зачем для этого больше получаса?


          1. vadimr
            03.10.2024 16:14
            +1

            Возьмите с полки пирожок.


          1. vadimr
            03.10.2024 16:14

            Если любите такие вещи, вот вам вопрос на понимание семантики вызова функции в Scheme.

            Предположим, у нас в программе есть такая функция:

            (define (f)
              (pp "Нисходящая ветка")
              (f)
              (pp "Восходящая ветка"))

            Зачем в этой функции предусмотрен код в восходящей ветке бесконечной рекурсии? Существует ли контекст вызова, в котором он сработает?


            1. Kergan88
              03.10.2024 16:14
              +1

              Существует ли контекст вызова, в котором он сработает?

              Language: racket [custom].
              > (define (f) (println "Нисходящая ветка") (f) (println "Восходящая ветка"))
              > (define g f)
              > (set! f (λ () null))
              > (g)
              "Нисходящая ветка"
              "Восходящая ветка"
              > 

              без set!, думаю, нельзя. ну и варианты с переопределение println, define или там #%app и других внутренних форм не рассматриваем.


              1. vadimr
                03.10.2024 16:14

                Точно.

                Ну или

                (begin (thread f) (set! f (lambda () 0)))


  1. xi-tauw
    03.10.2024 16:14
    +5

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


  1. aamonster
    03.10.2024 16:14
    +8

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


  1. TechnoMag82
    03.10.2024 16:14
    +8

    Встроенный единый список всех функций, языковых конструкций и операторов языка с Drag-n-Drop.

    Прежде, чем хотеть эту(и) фичу(и), взгляните на размер MSDN, к примеру.

    З.Ы. Android Studio уже начинает захлёбываться, когда открывает класс на >40K строк (а это очень популярный продукт), и во время начала ввода имени метода очень задумывается, составляя список возможных методов.


    1. a43mx Автор
      03.10.2024 16:14

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


    1. Krushiler
      03.10.2024 16:14

      Более того, Android Studio начинает захлёбываеться, когда просто открываешь код View или Context. А это самые базовые вещи в андроиде.


  1. dv0ich
    03.10.2024 16:14
    +8

    Ага, удачи освоить С++ за один день по подсказкам IDE :)


    1. a43mx Автор
      03.10.2024 16:14

      Так в том то и дело, что при текущем функционале IDE это не получится, вся статья про это


      1. artptr86
        03.10.2024 16:14

        А только лишь на подсказках IDE вы его тоже не освоите


        1. a43mx Автор
          03.10.2024 16:14

          Тут пол статьи не про подсказки


          1. nameless323
            03.10.2024 16:14
            +2

            Если вы не понимаете концепции языка, банально что такое указатели, что можно делать указатели на указатели (а это еще может оказаться просто указателем на массив) и так далее в плане указателей тех же, владение памятью, мемори моделы и т.д. и т.п., то вам никакая IDE не поможет, набрали вы * и что? Вам должно показать всю документацию по указателям и работе с памятью (и бонусом на умножение)? Тут уж проще книжечку прочитать (и не за один день)


            1. a43mx Автор
              03.10.2024 16:14

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


              1. nameless323
                03.10.2024 16:14
                +2

                Страница с полной документацией указателя это пол книжки K&R. А что делать с тем что оно может быть умножением, указателем, массивом (технически тоже самое, что указатель конечно, но это надо объяснить если человек не знает про управление памятью). И главный вопрос - а как человек вообще должен узнать что ему нужен в данном случае такой концепт языка как указатель, ссылка, или, скажем, мув семантика? При старте IDE открыть онлайн учебник или ссылку на книжку? Но зачем тогда это в IDE?


              1. artptr86
                03.10.2024 16:14
                +1

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

                auto x = ~

                ...и в этот момент ни компилятор, ни IDE ещё не знают, какой именно будет тип стоять справа от унарного оператора, чтобы получить правильную документацию в момент автодополнения или после него. Или может быть показана «стандартная» документация для побитового NOT, которая не будет иметь смысла, если, предположим, тильда для вектора — это получение противоположного вектора. Или ещё что-нибудь. Выводить же в выпадайке все возможные стандартные и перегруженные унарные операторы (вдобавок ко всем остальным доступным типам, переменным и функциям) — глупо.


                1. nameless323
                  03.10.2024 16:14
                  +3

                  Это автор еще не знает про темплейтный адъ (SFINAE, variadic templates, CRTP и так далее) который в языке творится :) Там IDE еще должна будет психологическую помощь оказывать людям, которые за один день будут это всё осиливать даже без других веселостей языка.


                  1. artptr86
                    03.10.2024 16:14
                    +1

                    Да хотя бы чтобы новичок понял, зачем нужна std::move, нужно гору всего узнать. Или даже как правильно перегрузить operator <=>


                1. a43mx Автор
                  03.10.2024 16:14

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


                  1. artptr86
                    03.10.2024 16:14

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


    1. hornT
      03.10.2024 16:14
      +2

      за 21 точно освоит :)


  1. S_gray
    03.10.2024 16:14
    +1

    Освоить любой язык программирования за один день? Для этого сначала придется понять, а зачем вообще нужны разные языки и почему надо осваивать какой-то новый язык. Последнее время тенденция такова, что чуть ли не под каждую новую фичу запускается проект нового языка - им конца-края не видно. Многие друг от друга практически не отличаются, а то и вообще являются просто надстройками над каким-нибудь javascript... Самый прикол начинается, когда тебе сначала рекламируют новый язык, говоря, "смари, как тут всё легко и быстро!", а на самом деле "легко и быстро" получается только после после подключения тыщи питсот библиотек (которые надо знать) и танцев с бубнами вокруг бесчисленных конфигурационных файлов...

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


    1. bromzh
      03.10.2024 16:14
      +1

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

      Приходите в брейнфак, там очень легко. Или самый лёгкий уровень - использовать только mov, всего 1 команда.