7 принципов, которые нужно знать начинающему программисту

Эта статья — не самоучитель по кодингу. И не пост о том, «какой язык программирования выбрать». Если вы хотите понять, насколько вам интересно изучать мир кода, то более важным вопросом будет: что такое программирование? Как выглядит программирование изнутри? Совместимы ли я и программирование?

Принцип «логика, а не математика»

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

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

Принцип «поймать падающую звезду»

На программирование можно смотреть, как на запуск множества «процессов» — как бы принуждение компьютера «делать работу за вас» — и управление этими процессами. В программировании процесс часто выдаёт некий результат. Результатом может быть файл, но может быть и нечто попроще, например строка, или число.

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

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

Принцип «словаря»

В программировании есть много «типов». Представляйте типы как строительные блоки языка программирования. Один из типов — это строка, или коллекция символов внутри кавычек. И «яблоко», и «апельсин» — это строки. Их можно, например, объединить и сделать «яблокоапельсин». Числа — это другой тип. Числа можно складывать, вычитать, умножать (помимо остальных действий). Затем идут «массивы» — множество объектов в определённом порядке. [«Первое», «идёт», «перед», «вторым»], например, является массивом с первым элементом «Первое» и последним элементом «вторым».

Но, возможно, одним из самых мощных типов является «хэш», или пара «ключ-значение». Хэш имеет много названий. В Ruby это «hash». В JavaScript он называется «object» (объект). Возможно, лучшее имя ему дал Python: «dictionary» (словарь). Если немного подумать, то словарь это и есть набор ключей (слов), указывающих на свои значения.

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

			{"first_name" => "Jonathan",
 "last_name" => "Richards",
 "nationality" => "British"
}
		

Есть ключи  «first_name» (имя), «last_name» (фамилия) и т.д. Это как бы свойства, или атрибуты человека. Можно ещё добавить «hair_colour» (цвет волос), «age» (возраст), или «gender» (пол). И каждый из этих ключей имеет значение. Значительная часть программирования связана с определением форматов структур данных. И пары «ключ-значение» становятся ценнейшим оружием в арсенале, поэтому полезно понять, как они работают, как можно раньше.

Принцип «матрёшек»

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

Добавим в предыдущий пример свойство «siblings» (братья/сёстры):

			{"first_name" => "Jonathan",
 "last_name" => "Richards",
 "nationality" => "British",
 "siblings" => {
               "brothers" => [Matthew, Pete, Simon],
               "sisters" => ["Fiona", "Mary"]
               }
}
		

Этот принцип вы будете встречать на протяжении всего программирования. В HTML одни элементы включают в себя другие элементы:

			<div id="outer_div">
    <div id="internal_div">
        <div id="yet_another_internal_div></div>
    </div>
</div>
		

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

Принцип «сосиски»

В вычислениях объектами в основном являются программы или файлы. Это крайне полезный принцип. В программировании вы часто услышите термины «in» и «out» — ввод и вывод. Причина в том, что задачей часто является получение входных данных (ввод), их обработка (процесс), и произведение изменений (вывод). Обработкой занимаются процессы (активные биты), которые управляются вашим кодом. Пассивными битами являются данные, с которыми работают процессы. Это всё похоже на превращение фарша в сосиску.

Принцип «собаки, кошки и рыбы»

(или принцип причинно-следственной связи)

Представьте, что у вас есть комната. В этой комнате есть кошка и рыба в чаше. Рыба ведёт себя как обычно. В определённый момент происходят 2 вещи: собака входит в комнату, а кошка выходит из комнаты. В то же время рыба начинает петь. Вопрос: что заставило рыбу петь?

Можно рассмотреть много возможностей. Можно предположить, это случилось потому, что вошла собака. А можно предположить, что причина в том, что вышла кошка. А может быть, причина в комбинации обоих событий. Возможно, оба события тут не при чём. А дело в том, что 18:17 — это время превращения рыбы в ведьму. Может быть, все рыбы поют. Некоторые из этих вариантов могут оказаться правдой.

Что действительно важно для программиста, так это уметь изолировать причины изменений. Вы будете сталкиваться с подобными ситуациями на протяжении всего времени, пока вы кодите. В таких ситуациях мы, возможно, захотим спросить себя: можем ли мы симулировать вход собаки без выхода кошки (это может многое прояснить); можем ли мы симулировать выход кошки без входа собаки; можем ли мы полностью воспроизвести обстановку (например, время 18:17), чтобы понять, влияет ли она на пение рыбы, вне зависимости от собак и кошек. И так далее. Очень важно применять методологию для установления причин изменений. Эта способность будет помогать вам снова и снова, пока вы кодите.

Абстракции, или принцип «пиццы»

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

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

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

Давайте превратим приготовление пиццы в код. Сначала начнём делать это неправильно. Сделаем метод make_a_napoletana_pizza (приготовить пиццу Неаполитана):

			make_a_napoletana_pizza
		

В нём будет 5 шагов (сделать основу, добавить томатный соус, добавить анчоусы, добавить сыр, запечь):

			make_the_base
add_the_tomato_sauce
add_anchovy
add_cheese
bake
		

Отлично. Но что, если мы хотим сделать пиццу салями? Мы будем вынуждены написать абсолютно новый метод make_a_salami_pizza (приготовить пиццу салями), у которого будет много общего с текущим методом, разве что он будет добавлять салями вместо анчоусов. Это несколько затратно. Программистский подход состоит в том, чтобы «абстрагировать» общие части методов приготовления пиццы и учесть различающиеся, специфичные ингредиенты. Мы можем сделать это с помощью «аргумента», который «передаётся» в метод.

Вот что имеется ввиду. Представим, что наш метод make_a_pizza (приготовить пиццу) вызывается с аргументом «toppings» (начинки). Метод будет выглядеть примерно так:

			make_a_pizza(toppings)
		

И он будет работать следующим образом:

			make_the_base
add_the_tomato_sauce
add_toppings(toppings)
add_cheese
bake
		

В 3-й строке мы берём начинки, определённые ранее, и добавляем их в пиццу.

Теперь, когда мы определили общий метод по приготовлению пиццы, мы можем просто вызвать его и задать ингредиенты, которые хотим. Всё происходит автоматически. Другими словами, мы вызываем make_pizza(salami), и когда метод запустится, salami (салями) станет toppings (начинкой) и добавится в пиццу, когда метод дойдёт до 3-й строки. Просто изменяя начинку, можно одним методом создать 2 разные пиццы. Это так же экономно, как когда официантка просто пишет в форме заказа «1 х салями, 1 х вегетарианская», и повар знает всё, что ему нужно. В программировании это называется «абстракция».

Так что мы имеем: семь принципов, которые обычно усваиваются в первые 3 года занятия программированием, и которые вносят значительный вклад в понимание искусства написания кода. Если вы начинаете своё путешествие, эти принципы могут помочь и вам.