Приемы чтения кода

Для начинающих программистов хорошим тоном всегда было – «учиться программированию у мастеров». А кто может быть лучшими мастерами, чем разработчики типовых решений?! Поэтому совершенно неудивительны попытки новичков открывать модули типовых решений и просто начинать читать код, следя за развитием логики алгоритма, подмечая ньюансы и приемы программирования.

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

И не беда, что поначалу половина кода кажется туманной и загадочной. Главное понимать его цель, отмечать основные вехи и как можно больше – читать, осознавать и брать на вооружение. По мере «набивания руки» в чтении кода – тумана и загадок будет оставаться все меньше.

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

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

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

Выход на нужный программный код

Ну что открываем «конфигуратор»?

Отнюдь!

Первым делом в любой ситуации полезно посмотреть на действие изучаемого механизма…  в пользовательском режиме программы!

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

Итак, правило первое: Перед началом анализа программного механизма, посмотрите на его действие «глазами пользователя».

Посмотрели.

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

Тут полезно вспомнить, что язык системы «1С:Предприятие» - язык событийный. То есть программный код – он не сам по себе, он задействуется только в ответ на некие события, возникающие после действий пользователя.

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

Как видите, найти обработчики событий, связанных с изменением элементов формы, достаточно легко. Надо лишь в эскизе формы задействовать контекстное меню на самом элементе, и в подменю "События" посмотреть – напротив каких обработчиков проставлена пиктограмма "Р()". Если проставлена – значит этому обработчику назначена процедура. А если обработчик подходит по смыслу нашей задачи – то именно эту процедуру надо прочитать, изучить.

Серфинг по коду

Порядок чтения изучаемой процедуры, разумеется,  - "сверху-вниз" и, по возможности, "ничего не пропуская".

Но одним из принципов структурного программирования является следующий: «повторяющиеся фрагменты программы нужно  оформлять в виде процедур и функций, вызываемых из программы». То есть надо быть готовым к тому, что очередная строчка кода в изучаемой процедуре будет не исполняемой командой, а именем "вызываемой из программы процедуры или функции". А вызываемая процедура или функция уже в свою очередь может включать в себя вызовы других процедур или функций, а те – других…

Фактически чтение "сверху-вниз" в типовых конфигурациях зачастую превращается в "серфинг" по вызывающим друг-друга процедурам и функциям. Как не "утонуть", не запутаться при этом серфинге – смотрим в следующем ролике:.

Итак, запомнили:

Шаг вперед:   < F12> - переход к определению вызываемой процедуры, функции или переменной;

Шаг назад: комбинация клавиш <Ctrl + " -"> (причем "минус" надо нажимать на верхнем ряду клавиатуры, а не на отдельной боковой).

Кроме этих двух основных приемов "серфинга" есть еще один вспомогательный:

<Alt + F12> - найти использование процедуры или функции. Эта комбинация клавиш позволит оценить "популярность" очередной процедуры или функции:

Анализ вызываемых процедур и функций

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

Читаем "сверху-вниз"?

Да, но… не сразу.

Что бы чтение функции (процедуры) сопровождалось еще и пониманием прочитанного – желательно придерживаться следующего плана:

1)      Контекст

2)      Комментарий

3)      Параметры

4)      Текст

То есть – текст в последнюю очередь.

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

1)      Где она расположена, и какое окружение ей доступно просто из-за того, что она расположена именно там?

2)      Что мне хотел посоветовать/пояснить автор этой функции?

3)      Какие данные (недоступные из контекста) автор бы вынужден передать со стороны вызывающей процедуры(функции)?

В следующем ролике показано – как именно это осознание можно выполнять:

Ну что ж, осознали.

Вот теперь можно приступать к чтению:

Синтакс-помощник, помогай!

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

• входной для "черного ящика" информации;
• планируемого действия черного ящика;
• выходной из "черного ящика" информации;
• особенностей поведения "черного ящика".

Так вот, все это описание содержится в инструменте платформы "Синтакс-помощник":

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

Ну, вот смотрите сами, как идет дальнейший анализ нашей функции:

А вот так освоенные нами "F12", <Ctrl + " -">  и "Поиск в Синтакс-помощнике" помогают осознать следующую часть алгоритма:

Изучение привлекаемых объектов

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

Отладчик, показывай!

Хорошо когда Вам абсолютно прозрачны преобразования данных, выполняемые в коде алгоритма. То есть читаете код и понимаете: "ага, сюда, значит, у них заходит проволока, вот этот барабан крутится, вот эти насадки загибают, а вот эта – обрезает... "

Но иногда понимание сводится к следующей схеме:

Наглядность! Вот что требуется при чтении сложных фрагментов кода.

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

Так вот, платформа "1С:Предприятие" имеет шикарный инструмент для обеспечения наглядности. Называется он – "Отладчик".

Воспользуемся:

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

За работу, товарищи!

А что в алгоритме было дальше… -  узнайте, пожалуйста, сами.

Ну, правда, попробуйте.

Убедитесь, что это не сложно и по-своему приятно.

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