Считается, что "программирование - это сложно". Что нельзя вот просто так взять, и сходу начать работать с незнакомым языком программирования, сразу написав работающую программу, либо разобраться в уже готовой. Да, сейчас это действительно не просто, и у вас на пути будет множество трудностей, из-за которых вы можете развернуться и уйти, так и не доделав начатое до конца. Однако многие из них уже в ближайшем будущем могут быть решены. Вы спросите, а как именно? Вот об этом и пойдет речь в данной статье.
Все приведенные ниже примеры, скрины и сочетания клавиш рассматриваются в средах разработки от Jetbrains на платформе Intellij.
Но почему именно Intellij?
Ну во первых, в остальных IDE функционал еще более урезанный чем здесь. А во вторых, именно на этой платформе самый большой набор IDE для разных языков программирования. А поскольку платформа общая, то это значит, что как только в нее добавляется новая фича, то как правило, она сразу становится доступна для всех IDE этой платформы, а значит, будет доступна для соответствующих им ЯП.
Оглавление:
Встроенный единый список всех функций, языковых конструкций и операторов языка с Drag-n-Drop.
Поддержка вложенного предпросмотра кода функций/методов/классов и т.д.
Поддержка вложенного поиска мест использования функций/методов/классов и т.д
SQL - графический интерфейс для операций чтения (в том числе JOIN и GROUP-BY HAVING)
Выводить неочевидные фичи в контекстном меню отдельным пунктом
Раздельные цвета для встроенных и пользовательских функций/методов/классов и т.д.
Встроенная документация для операторов и языковых конструкций
1. Встроенный единый список всех функций, языковых конструкций и операторов языка с Drag-n-Drop.
Итак, вы хотите попробовать написать программу на языке, с которым никогда не работали. И вот вы установили IDE для работы с ним, открыли его, создали проект, а что дальше? А дальше ничего, ведь никаких функций, языковых конструкций, и операторов данного языка вы не знаете, и свою первую программу вам будет буквально не из чего писать. В итоге вам придется будет пойти в гугл, искать мануалы и справочники, изучать их. Уже на этом этапе вы скорее всего развернетесь и уйдете, если не готовы выделить на это время. К тому же нет гарантии, что вы их быстро найдете, а тогда вы и вовсе сделаете вывод, что их нет. Но все могло быть по другому, будь в IDE встроенный единый структурированный древовидный список функций, языковых конструкций и операторов, распределенных по разделам (к примеру для функций - функции для работы с массивами, функции для работы со строками и т.д). Откуда можно было бы 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, то такой возможности пока нет, и запросы с данными операторами нужно будет писать самому. Но это тоже можно было бы реализовать в графическом интерфейсе, путем выбора таблиц, которых нужно присоединить друг к другу, и выбора полей, по которым должны быть присоединение. Ну и возможность выбора полей для группировки.
В итоге можно будет освоить запросы 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 Выполнение функций/методов/классов отдельном окне - ссылка на тикетБыстрое выполнение кода прямо в редакторе, либо с копированием в отдельное окно - REPL GUI - ссылка на тикет
2.1 Cистема хранения и генерации примеров переменных - ссылка на тикетВложенный предпросмотр кода функции/метода/класса - ссылка на тикет
Вложенный поиск мест использования функций/методов/классов - ссылка на тикет
Графический интерфейс для операций JOIN и GROUP BY в SQL - ссылка на тикет
Вывод неочевидных фич, доступных в месте клика, в контекстное меню с помощью отдельного пункта - ссылка на тикет
6.1 Страница с описанием неочевидных фич, доступных в месте вызова меню - ссылка на тикетНавигация по коду с учетом наследования классов ООП - ссылка на тикет
Раздельные цвета для встроенных и пользовательских функций/классов и т.д. - ссылка на тикет
Встроенная документация языковых конструкций и операторов - ссылка на тикет