1. Что нужно для того, чтобы стать программистом.

1) Желание (как и в любом деле). Без этого ничего не получится. Нужно буквально «заболеть» этим, нужно, чтобы доставлял удовольствие сам процесс.

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

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

4) Очень желательно знание английского языка, так как подавляющее большинство языков программирования построены на английском языке.

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

6) Для того, чтобы быть действительно классным программистом, необходима богатая фантазия. Речь идёт не о литературной фантазии, а о технической, об изобретательности. То есть нужно уметь придумывать самые невероятные конструкции из простых объектов. Хотя фантазия – она всегда фантазия, её можно приложить к любой области, и если есть литературная, то при желании можно развить и техническую.

7) Это может показаться странным, но нужно быть в определённой степени... ленивым! Или лучше – хорошо понимать ленивых людей. Основная задача программиста – переложить как можно больше операций с человека на ЭВМ. Чтобы ЭВМ вкалывала, а человек отдыхал.

8) А ещё нужно быть хитрым и изворотливым. Чтобы придумывать изящные методы решения программистсих задач, а не тупо «в лоб» - это зачастую неэффективно, и твои программы будут тормозить и подвисать, а их пользователи – ругаться и материться

2. Самые начальные сведения о программировании.

Компьютерная программа – это алгоритм, записанный на специальном языке (языке программирования). Алгоритм же – набор команд. При написании любой программы используются английские (и иногда русские) слова, цифры, скобки, кавычки, знаки препинания и арифметические знаки. Всё это «добро» образует язык программированя (существует много разных языков программирования). Команды в алгоритмах бывают разные. Например: «Написать слово», «Начертить окружность», «Сложить два числа», и т.д. При запуске программы ЭВМ сначала проверяет, нет ли в программе совсем уж грубых ошибок. И если такие ошибки есть, она начинает «ругаться», и ругается до тех пор, пока ты всё не исправишь. Ну а если всё нормально, то она начинает её, эту программу, выполнять, команду за командой: писать слова, чертить фигуры, производить вычисления, и т.д. Конечно, если программа запустилась, то это не значит, что можно успокоиться и начать гордиться собой. Ведь в программе вполне может остаться ещё куча ошибок, из-за которых она будет «глючить», зависать, выводить неверные результаты. Самый, пожалуй, сложный этап программирования – поиск и исправление ошибок. Чем сложнее, объёмнее программа, и чем ниже уровень программиста, тем больше времени на это затрачивается.

3. Основные понятия.

1) Разветвление. Очень часто в программах встречаются разветвления, то есть в зависимости от конкретной ситуации может выполняться либо одна последовательность команд, либо другая, либо третья, и так далее. Мы тоже так часто делаем. Например, если на улице сухо и тепло, идём гулять, а если дождь и холод - сидим дома и, допустим, смотрим телевизор. В только что рассмотренном разветвлении две ветви. Графически всё это можно изобразить так:

Этот рисунок, кстати, называется блок-схемой алгоритма.
Бывают разветвления и с тремя, и с ещё большим количеством ветвей. И ещё один момент: каждая из ветвей какого-либо разветвления может, в свою очередь, тоже разветвиться, а ветви этого «вложенного» разветвления тоже могут разветвиться, и т.д. Получается как бы дерево.

2) Цикл. Это когда одна и та же последовательность комманд выполняется несколько раз подряд, до тех пор, пока что-то не случится (не выполнится какое-то условие – условие выхода из цикла). Повторяющаяся последовательность команд называется телом цикла. Здесь тоже можно привести пример из жизни – выкапывание картошки на огороде. Алгоритм здесь такой: воткнуть лопату в землю, выкопать куст с картошкой, сделать шаг назад, и снова то же самое, и снова, и снова, пока не закончится грядка. А вот – блок-схема:

Такой цикл называется циклом с постусловием. Называется так потому, что проверка условия выхода из цикла (закончилась грядка или нет) производится в конце, после тела цикла. Тело такого цикла тело по-любому выполняется хотя бы один раз. В случае с картошкой так и должно быть, ведь хотя бы один куст в грядке должен быть! Иначе это не грядка… А бывают ещё циклы с предусловием. В этих циклах проверка осуществляется, наоборот, в начале, перед телом. Приведу пример такого цикла. Перед тобой – тарелка. Там могут быть ягоды, а может и ничего не быть. Твоя задача – если ягоды в тарелке есть, нужно их все съесть. Алгоритм такой. Пока тарелка с ягодами не пуста, повторять такие действия: взять ягоду из тарелки, положить её в рот, разжевать, проглотить, выплюнуть косточку. Рисуем блок-схему:

Тело этого цикла может не выполниться и ни разу (если ягод в тарелке изначально не было)... Очень часто начинающие программисты недоумевают, какой цикл в программе лучше исползовать: c предусловием или с постусловием. А ведь всё проще некуда. Нужно выяснить, должно ли тело цикла выполниться хотя бы один раз, или может не выполниться и ни разу. И всё станет ясно. А если не ясно – используй цикл с предусловием. Не ошибёшься.
Замечу, что внутри одного цикла может быть другой, а внутри другого – ещё один, и так далее. Как матрёшки.

3) Переменная. Это как бы маленький ящик. В него можно «положить» число, букву или значок, слово или предложение, и т.д. Ящики бывают разных типов. Те, что предназначены для хранения чисел – это числовые переменные, для хранения букв и значков – символьные, для хранения слов или предложений – строковые. У каждого «ящика» (каждой переменной) должно быть имя. Имена могут состоять как из одной буквы, так и нескольких десятков букв. Буквы в подавляющем большинстве языков программирования – латинские. В именах (или, по-научному, идентификаторах) могут содержаться и цифры, и знаки подчёркивания ( _ ). Одно только замечание: идентификатор не может начинаться с цифры и не должен разрываться пробелами. «x», «Year2006», «My_best_friend» – правильные идентификаторы. «2006year», «My best friend» – неправильные.
Допустим, у нас есть переменная по имени x. Команда «x = 3» означает «положить в ящик x число 3», или, по-научному, «присвоить переменной x значение 3». Теперь в этом ящике хранится тройка. И храниться она будет там до тех пор, пока мы не положим туда другое число. После выполнения команды «х = 5» тройка из ящика «вышвырнется», в него положится пятёрка. Теперь допустим, что у нас есть ещё одна переменная – y. Команда «y = x» означает «скопировать в ящик y то, что хранится в ящике x».
Пусть у нас есть маленькая прораммка:

x = 3
y = 5
x = y

Чему станет равен x в результате её работы? Правильно, пяти. В него, в ящик x, скопировали то, что хранится в ящике y, а в ящике y хранится именно пятёрка, мы её перед этим туда положили. Заметь (важно!): при выполнении 3-й строчки переменная y не получила значения, хранящегося в x (то есть 3)! В ней осталась пятёрка! А то подумаешь ещё, что переменные x и y обменялись значениями! Если бы 3-я строчка была «y = x», вот тогда бы в y вложилось то, что хранится в x (тройка), но x остался бы тройкой!
А как изменить значение переменной? Скажем, увеличить x на 1? А вот так: «x = x + 1». ЭВМ снчала вычисляет выражение, стоящее после «=», а потом записывает результат вычислений в переменную, стоящую перед «=».

4) Массив. Это как бы большой, сложный «ящик», состоящий из нескольких «секций», и в каждой секции лежит что-нибудь. Все секции (важно!) имеют одинаковый тип, то есть нельзя в одну секцию положить число, а в другую – слово. Секции называются «элементами массива». А сам массив тоже должен иметь имя. А ещё он имеет размер (т.е., сколько в нём секций).
Пусть у нас имеется числовой массив A из пяти элементов. Если написать «A(1) = 20», то в первую секцию массива положится число 20. Точно также можно заполнить числами и все остальные секции.
Допустим, в нашем массиве хранятся числа 20, 35, 4, 67 и 48. Что получается? A(2) – это 35, A(5) – это 48, и так далее. Это понятно, да? Теперь, если, например, выполнить команду «x = A(3)», то чему станет равен x? Правильно, 4, ведь A(3) – это 4. А чему равно A(x)? Да, действительно, раз x – это 4, то A(x) – это то же самое, что A(4), то есть 67. Всё вроде бы просто, да? Кстати, числа, стоящие в скобках – это индексы элементов массива. Причём индексы не обязательно должны быть числовыми. В некоторых языках программирования они могут быть и символьными, но тогда символы нужно заключать в кавычки или апострофы, иначе ЭВМ может подумать, что в скобках стоит переменная. Пример: «А('x') = 34».
Массивы обычно обрабатываются в цикле. Например, вот так выглядит алгоритм для вывода на экран всех элементов массива A:

В самом начале переменной i присвоится 1. Потом выведется A(i), т.е. A(1), т.е. 20. Потом i увеличится на единицу, становится равно 2. 2 < 5, поэтому мы возвращаемся назад, и начинается второй шаг цикла. Опять выполняется команда "Вывести A(i)", но ведь i уже не 1, а 2, и выведется A(2), т.е. 35! Потом поочерёдно, шаг за шагом, будут выводиться A(3), A(4) и A(5). А когда i превысит 5, произойдёт выход из цикла. Я использовал цикл с постусловием, потому что заранее известно, что в массиве 5 чисел, и тело цикла должно по-любому выполниться хотя бы один раз.
Теперь – более сложный пример: поиск максимального числа в массиве. Но сначала приведу пример из жизни. Пусть у нас имеется кучка яблок разных размеров. Как выбрать самое большое из них? Я бы поступил так. Взял бы первое попавшееся яблоко и отложил. Потом взял бы следующее яблоко из кучки и сравнил его с отложенным. Если новое окажется больше отложенного, то положил бы это новое на место отложенного. А если не больше, то ничего бы не делал. Потом взял бы следующее яблоко из кучки и проделал бы тоже самое (опять сравнил бы его с отложенным, и заменил бы отложенное им при необходимости). Это наше отложенное яблоко является ничем иным, как самым большим яблоком на данный момент проверки. А я продолжаю брать из кучки яблоки и сравнивать, производя при неоходимости замены. И так – пока не опустеет кучка. В итоге отложенным окажется самое большое яблоко. Вот – блок-схема алгоритма:

А теперь перейдём к нашему массиву. Напомню: в массиве у нас числа 20, 35, 4, 67 и 48. С массивом мы поступим примерно также, как и с той кучкой яблок. Т.е. будем брать из него элементы по порядку, и сравнивать их с «отложенным». Привожу блок-схему.

Введённая мною переменная Max – это и будет «отложенный» элемент, в этой переменной будет храниться максимальное на данный момент проверки число массива. Для начала присвоим Max значение первого элемента массива, т.е. 20. А i присваиваем значение 2. Почему 2? А потому что одно число из массива мы уже «отложили», и массив нужно проверять, начиная со второго элемента. Ну что ж, начинаем проверять. Производим сравнение A(i), т.е. A(2), с Max, который сейчас равен 20. A(2) равен 35, а это больше 20, поэтому выполняется присваивание «Маx = A(i)», т.е. «Max = 35», и Max теперь стал равен 35. Потом выполняется строчка «i = i + 1», и i становится равно 3. 3 < 5, поэтому мы возвращаемся назад, и начинается второй шаг цикла. Опять A(i) сравнивается с Max, но A(i) – уже 4, т.к. i сейчас – 3. 4 сравнивается с Max, который сейчас уже не 20, а 35. 4 меньше 35, поэтому команда "Max = A(i)" не выполняется, и Max остаётся равен 35. Теперь – опять "i = i + 1", i стало 4. Следующий шаг цикла. A(i), т.е. 67, сравнивается с x, который равен 35. 67 больше 35, поэтому выполняется "Max = A(i)", и x становится 67. Опять "i = i + 1", i стало 5. Опять A(i) сравнивается с Max, т.е. 48 сравнивается c 67. 48 меньше 67, "Max = A(i)" не выполняется, Max остаётся 67. И опять "i = i + 1", i теперь стало 6. Но 6 > 5, а цикл может выполняться, только когда i меньше или равно 5. Поэтому происходит выход из цикла, и выводится на экран Маx, т.е. 67 (максимальное число массива).
До сих пор мы рассматривали простые, так называемые одномерные массивы, т.е. такие, у которых всего одно измерение, и каждый элемент имеет только один индекс. Но массив может быть и двумерным. В двумерных массивах уже два измерения, и каждый элемент имеет два индекса. Каждое измерение имеет свой размер. Чувствую, что пока не совсем ясно, что такое двумерный массив. Но, надеюсь, после примера всё станет ясно. Пример двумерного массива – поле для игры в «Морской бой». Здесь два измерения – длина и ширина, размеры обоих измерений равны 10, а каждый элемент (клетка) описывается двумя индексами: числовым и буквенным (символьным): «а-5», «д-10». Массивы могут быть и трёхмерными, и многомерными. Но в программах редко возникает надобность в массивах с более чем тремя измерениями.
Пусть у нас имеется двумерный массив A с размерами измерений по 5. Вот как происходит обращение к элементам двумерного массива: «A(3, 7) = 5». А как вывести на экран все элементы двумерного массива? Привожу блок-схему алгоритма.

Здесь два цикла с постусловием, вложенные друг в друга. Кроме переменной i, есть ещё j. i cлужит для одного измерения, j – для другого. Если внимательно проследить по схеме за выполнением команд, то можно заметить, что элементы массива будут выводиться в следующем порядке:

A(1, 1) A(1, 2) ... A(1, 5)
A(2, 1) A(2, 2) ... A(2, 5)

...

A(5, 1) A(5, 2) ... A(5, 5)

То есть, если представить наш массив как поле, где строкам соответствует индекс i (от 1 до 5), а столбцам - j (тоже от 1 до 5), то сначала мы «сканируем» первый столбец сверху вниз, потом второй, и так далее.

5) Запись. В некоторых языках программирования её называют также структурой. Это тоже большой и сложный «ящик», и он тоже, подобно массиву, состоит из нескольких секций, но он отличается от массива тем, что в этих секциях могут лежать разнотипные данные (в одних секциях – числа, в других – слова, и т.д.). У записи нет измерений, а секции называются полями записи, и у полей тоже есть имена. При помощи записи можно описать сложный объект, имеющий несколько свойств. Например, человека. В переменной-записи, описывающей человека (назовём её Men), будут такие поля:

– FIO (ФИО) – строковое поле
– Gender (пол) – символьное поле («м» или «ж»)
– Age (возраст) – числовое поле
– Growth (рост) – числовое поле
– Weight (вес) – числовое поле
– Address (адрес) – строковое поле

Обращение к полям записи осуществляется через точку. Например:

Men.FIO = «Иванов И.И.»
Men.Gender = «м»
Men.Age = 20

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

6) Таблица. Предположим, что нам надо описать целую группу людей (напимер, институтскую). Что нам для этого нужно сделать? Создать массив записей! Т.е. такой массив, каждый элемент которого представляет собой запись. Назовём этот массив Group. Обращение к полям элементов массива будет таким: Group(3).FIO = «Петрова М.А.» (мы обратились к полю FIO 3-го элемента массива Group). Наш массив записей – это и есть таблица. Вот её начало:

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

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

7) Подпрограмма. Очень часто бывает так, что в нескольких местах программы нужно выполнить одну и ту же последовательность команд. В таком случае, чтобы сделать алгоритм короче, оформляют эту последовательность команд в виде отдельной маленькой программки с именем, которая и называется подпрограммой. А потом в тех местах основной программы, где встречались те самые последовательности команд, можно эти последовательности заменить одной единственной командой – командой вызова подпрограммы. Удобно, не правда ли?
Замечу, что названия подпрограммам даются по тем же правилам, что и переменным (нельзя начинать их с цифр, и т.д.). В одной программе может быть несколько подпрограмм. И, конечно же, в подпрограмму можно вводить переменные любых типов, массивы, и т.д. Причём они будут «принадлежать» только данной подпрограмме, их нельзя будет использовать в основной программе (поэтому их называют локальными) А вот переменные основной программы (называемые глобальными) можно использовать во всех подпрограммах... А ещё скажу, что в некоторых языках программирования можно делать подпрограммы внутри подпрограмм.
А что, если в разных местах программы выполняются одни и те же действия, но над разными переменными? Допустим, у нас есть такая программа:

Считать с клавиатуры x
x = x / 2
Вывести x
Считать с клавиатуры y
y = y / 2
Вывести y

Можно ли повторяющиеся действия над разными переменными тоже оформить в подпрограмму? Можно! Но в таком случае у подпрограммы будет параметр. Назовём его a. Подпрограмма (назовём её Sub) будет выглядеть вот так:

Подпрограмма Sub(а)
Считать с клавиатуры a
a = a / 2
Вывести a
Конец

А основная программа станет короткой-прекороткой:

Вызвать Sub(x)
Вызвать Sub(y)

При вызове подпрограммы та переменная, что стоит в скобках, копируется в параметр a, потом выполняются команды подпрограммы.
Подпрограмму можно вызывать и для простых чисел (или символов). Например, Sub(4) выведет 2, т.е. она присвоит параметру a переданное значение 4, разделит его на 2 и выведет.
У подпрограммы может быть и несколько параметров. Тогда они разделяются запятой (или точкой с запятой, всё зависит от языка программирования): Sub(а, b), и при вызове перечисляются в том же порядке: Sub(x, y); x будет копироваться в a, y - в b.
Подпрограмма может возвращать какое-то значение, тогда она называется функцией. Вот, например, функция суммы двух чисел:

Функция Sum(a, b)
 c = a + b
 Возвратить c
Конец

Теперь эту функцию можно использовать следующим образом:

z = Sum(2, 3)

И z присвоится значение суммы чисел 3 и 2, т.е. 5.

8) Класс. С развитием науки программирования люди поняли, что удобно было бы объединить «в одном флаконе» поля и функции. То есть как бы в запись к полям (свойствам) добавить ещё и функции, которые будут обрабатывать эти поля - так называемвые «методы». Так, например, будет выглядеть простейший класс из двух свойств-чисел и двух методов, возвращающих сумму и произведение полей:

Класс Math
 a: число
 b: число
 Метод Sum
 Метод Prod
Конец

Метод Math.Sum
 c = a + b
 Возвратить c
Конец

Метод Math.Prod(a, b)
 c = a * b
 Возвратить c
Конец

Теперь можно объявлять экземпляры этого класса - «объекты». Пусть объект Obj будет класса Math. Тогда при выполнении такой программы:

Math.a = 3
Math.b = 4
Вывести Math.Sum
Вывести Math.Prod

выведется сначала 7 (сумма полей), а потом 12 (произведение).

Введенние понятия «класс» в программирование ознаменовало эру ООП (объектно-ориентированного программирования). В ООП широко используется такая удобная вещь, как наследование. То есть, если мы объявим какой-либо новый класс наследником нашего класса Math, то, будучи вроде бы пустым, он уже будет содержать в себе поля a, b и методы Sum и Prod, которые он унаследует от Math, и можно добавлять что-то ещё, а потом, возможно, объявить наследника уже от этого класса, и он унаследует всё как от него, так и от изначального класса Math.

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

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

Блок-схемы алгоритмов в этой лекции были построены при помощи моей программы - автозарисовщика блок-схем. Она тоже может быть полезна при изучении программирования, если в качестве первого своего языка ты выберешь Pascal (или его современную версию - Delphi).
А пройдя вот этот тест, ты сможешь узнать, каковы твои шансы стать программистом.
Удачи!