Первая лекция. От ассемблера и мейнфреймов — до ООП, асинхронности и современных языков. Реальные исторические примеры кода: Fortran, COBOL, ALGOL, Pascal, C, C++ → Python/Java/JS. Покажу реальные исторические примеры кода и объясню, что именно каждый язык добавлял нового и какие проблемы решал — и как это привело к современному стеку.
*https://www.youtube.com/watch?v=j-Z163ImJsY
**https://300.ya.ru/v_Dv6nvAIh
таймкоды
00:00:00 Введение
- Обсуждение истории программирования от начала до наших дней.
- Примеры кода из разных эпох программирования.
- Видео как гайд для подготовки к собеседованиям.
00:01:33 История программирования
- Программирование возникло в XIX веке.
- Чарльз Бэббидж и Ада Лавлейс: аналитическая машина и первые программы.
- Упоминание языка программирования ADA, названного в честь Ады Лавлейс.
00:02:36 Первые ЭВМ и ассемблеры
- Появление первых ЭВМ в США в начале 1940-х годов.
- Изобретение первого процессора в Манчестерском университете в 1948 году.
- Развитие ассемблеров как трансляторов низкоуровневых языков программирования.
00:03:35 Ассемблеры и их особенности
- Прототипы ассемблеров в 1940-х годах.
- Появление зрелых ассемблеров, таких как SAP на IBM 704, в середине 1950-х.
- Поддержка мнемоник и меток в ассемблерах. 00:04:32 Работа с перфокартами
- Отсутствие жёстких дисков, клавиатур и мониторов у ранних компьютеров.
- Использование перфокарт для ввода данных и вывода результатов.
- Преобразование кода в текстовый формат для печати на принтере.
00:07:21 Пример кода на ассемблере
- Разбор примера кода для IBM 704 1957 года.
- Использование мнемоник для процессорных команд.
- Задача кода: сравнение данных с контрольной суммой и остановка выполнения на error или good.
00:10:20 Условные переходы в ассемблере
- Команда CAS для сравнения аккумулятора с ячейкой памяти.
- Реализация условных переходов без использования if.
- Пример обхода цикла в ассемблерном коде.
00:12:16 Эпоха мейнфреймов и ассемблеров
- В 50-е и 60-е годы компьютеры были крупными и использовались учёными в университетах, НИИ и компаниях.
- Ассемблеры были слишком привязаны к железу, поэтому появились первые мощные языки программирования.
- Fortran стал стандартом для научных расчётов, а COBOL — для бизнес-вычислений.
00:13:16 Процедурные языки программирования
- Процедурные языки воспринимают программу как последовательность шагов с переходами между частями кода.
- Единицей программы являются процедуры или функции.
- Функция возвращает значение, а процедура может иметь побочные эффекты.
00:13:41 Создание Fortran
- Fortran разработан командой IBM под руководством Джона Бэкуса для научных задач.
- Компилятор Fortran выдаёт код, почти не уступающий рукописному на ассемблере.
- Fortran активно использовался во второй половине XX века и начале XXI века.
00:14:40 Значение Fortran
- Fortran заложил основу переносимости и стандартизации в программировании.
- К середине 60-х годов Fortran стал первым национальным стандартом.
00:15:01 Пример кода на раннем Fortran
- Пример кода из архивного документа НАСА показывает использование условных переходов и меток.
- Условный переход осуществляется с помощью конструкции «goto».
- Метки в коде располагаются хаотично, что неудобно для больших программ.
00:17:19 Вызов процедур и циклы в Fortran
- Вызов процедуры осуществляется с помощью конструкции «call».
- Циклы в Fortran описываются с помощью конструкции «do».
- Синтаксис циклов сохранялся до версии Fortran 90.
00:19:43 Создание COBOL
- COBOL создан в 1959 году для деловых и финансовых программ.
- Программы на COBOL читаются как естественный язык.
- COBOL стал популярным в 60-е и 70-е годы в госучреждениях и финансовых организациях США.
00:20:48 Спецификации и структура кода COBOL
- Спецификации COBOL содержат более 200 зарезервированных слов.
- Код COBOL имеет структуру: identification division, environment division, working storage division, procedure division.
- Пример кода вычисляет зарплату сотрудникам, используя процедуры и циклы в стиле Алгола.
00:22:17 Особенности кода COBOL
- Присваивание значений в COBOL осуществляется с помощью команды «move».
- Команда «add» означает сложение.
- Особенности принтера, на котором печатался код, влияли на его синтаксис.
00:23:33 Синтаксис цикла в Каболе
- Цикл выполняется с увеличением переменной monthly pay на 10 до тех пор, пока она не станет больше 1000.
- Переменная monthly pay используется как глобальная и изменяется внутри цикла.
00:24:30 Условные переходы в процедуре testHashTotals
- Используются условные переходы с оператором сравнения «равно».
- В зависимости от условий, переменные correct message или incorrect message копируются в output record.
00:25:30 Особенности синтаксиса Алгола
- Программа написана на английском языке, что делает её легко читаемой.
- В 50–60-е годы программы могли быть такими же простыми и понятными.
00:26:01 История создания Алгола
- В 1958 году европейцы выпустили Алгол-58, опередив Fortran на год.
- Над разработкой языка работали ведущие специалисты, включая Джона Бэкуса и Джозефа Бекстейна.
- Алгол был структурным языком с блоками begin и end и подпрограммами.
00:26:57 Проблемы и оптимизация Алгола
- В США не было компьютеров, поддерживающих ввод и вывод 116 букв из стандарта Алгола.
- Язык требовал оптимизации из-за низкой производительности компьютеров того времени.
00:28:45 Влияние Алгола на последующие языки
- Алгол заложил основы структурного программирования и современного бинарного if then else.
- Опыт разработки Алгола повлиял на создание Pascal.
00:29:21 Пример кода компилятора Алгола
- Лексер компилятора отделяет полезный код от комментариев.
- Код организован с использованием блоков begin и end.
00:30:16 Структура кода и операторы
- Метка next 0 используется для переходов по коду.
- Оператор присваивания двоеточие равно применяется для назначения значений переменным.
00:32:27 Логические операторы и циклы
- Логические операторы «и» и «или» используются для сложных условий.
- Цикл реализуется через прыжки по меткам, так как в Алголе не было операторов while или repeat.
00:34:23 Влияние Алгола на последующие языки
- Алгол повлиял на язык ABC, который, в свою очередь, повлиял на Python.
- Хорошая читаемость и организация кода — наследие Алгола.
00:35:00 Создание Pascal
- В 1970 году Клаус Вирт разработал язык Pascal для обучения программированию.
- Pascal — структурный язык с строгой типизацией и небольшим набором функций.
- Основные конструкции: последовательность, ветвление и циклы.
00:35:53 Преимущества структурного программирования
- Структурное программирование позволяет размещать логику в коде более структурированно.
- Теорема Бьома-Якопини: любой детерминированный алгоритм можно выразить комбинацией последовательности, ветвления и цикла.
- Распространение клавиатур ускорило принятие идей структурного программирования.
00:36:49 Применение Pascal
- Pascal упростил идеи структурного программирования и стал массовым языком.
- Использовался в университетах и коммерческом программировании в 70–80-х годах.
- В 80–90-е годы на Pascal писали приложения для macOS, файловые менеджеры и игровые движки.
00:37:47 Пример кода на Pascal
- Код рисует линии на растровом экране, избегая зигзагов и зубчиков.
- Главная процедура DrawLine принимает аргументы: дельта Y, дельта X и Inc.
- Вложенные процедуры и блоки begin-end обеспечивают структурированность кода.
00:39:42 Выбор процедуры
- Условие if delta x больше delta y выбирает процедуру для рисования линии.
- Прямой цикл repeat until i равняется 0 заменяет переходы по меткам.
- Конструкция switch case определяет выбор чернил: белые, чёрные или радар.
00:41:36 Лексическая область видимости
- Лексическая область видимости позволяет функциям видеть внешние переменные.
- Переменные, объявленные внутри функции, недоступны вне этой функции.
- Pascal сочетает структурный подход с лексической областью видимости, пришедший из Алгола.
00:42:33 Философия Pascal
- Pascal подразумевает структурное программирование, избегая переходов по меткам GoTo.
- Философия языка направлена на комбинацию последовательности, ветвлений и циклов.
In this video
Вступление
0:00
Когда изобрели операторы if else? В каком языке появилось объектноориентированное программирование? Как устроено
0:06
асинхронное программирование и какие проблемы решало структурное программирование? Мы разберём
0:11
самые-самые распространённые стили и парадигмы. И я не просто про них расскажу, а покажу на примерах кода, как
0:17
программы выглядели в разные эпохи программирования, что в них менялось и что нового появлялось в языках с каждым
0:22
десятилетием. В этом видео я расскажу полную историю программирования от начала и до наших дней с примерами кода.
0:28
Всем привет. Вы на канале Помидор Devвеeloper и это полная история программирования.
0:37
Это видео можно также использовать как такой гайд для подготовки к собеседованиям или если хотите просто в
0:43
нужный момент блеснуть знаниями. И, что, наверное, самое главное, вы будете лучше понимать программирование в целом.
0:50
Конечно, я не смогу рассказать про все языки программирования. Это было бы очень долго и вообще, если возможно, но
0:56
я возьму самые значимые из них и расскажу про них в теории и на практике. Но перед тем, как мы начнём, я хотел бы
1:02
вас попросить поставить лайк этому видео и подписаться на канал. Особенно важно — это подписка. От неё во многом зависит
1:09
алгоритмы Ютуюба, и так вы поможете этому каналу развиваться. А по окончанию этого видео, чтобы проверить, насколько
1:15
вы хорошо усвоили всю информацию, на сайте jango.run/history вы сможете пройти тест по истории
1:22
программирования бесплатно и без регистрации. Этот тест я составил на основе информации, которая будет в этом
1:28
видео.
Зарождение программирования
1:33
Программирование возникло ещё в XIX веке, и долгое время до изобретения электричества программирование
1:38
оставалось теоретической наукой, так же как и математика. Первым компьютером
1:43
можно считать аналитическую машину, которую после десятилетий экспериментов в 1837 году изобрёл Чарльз Бейбридж,
1:51
английский математик и изобретатель. Это была реальная механическая вычислительная машина, которая умела
1:57
делать сложение, вычитание и умножение. А графине математик Ада Лавлис, дочь
2:03
поэта Джорджа Байрона, сделала описание этой машины и инструкции по программированию к ней. Их можно считать
2:09
первыми в мирепрограммами. Позже, в 1970 годах в США в честь Ада Lovel назовут
2:15
язык программирования Ада. Подобно тому, как Жакардов ткацкий станок может ткать цветы и листья, аналитическая машина
2:21
способна создавать алгебраические формулы, а в перспективе писать музыку, писать картины и укажет науке такие
2:28
пути, которые нам они снились. А The L как в воду глядела.
Assembler
2:37
В начале сороковых годов США стали появляться первые электронно-вычислительные машины. В 1948
2:44
году в Манчестерском университете в США изобретают первый процессор и возникает
2:49
необходимость писать под него инструкции. Первые программисты писали числовые коды, которые обозначали
2:56
инструкции к процессору. Вот так просто на бумаге. Потом эти данные переносили на перфокарту и считывали с неё на
3:02
компьютере. Но это было не очень удобно, поэтому довольно быстро появились ассемблеры. С английского ассемблер
3:09
переводится как сборщик. Асмпlerлер — это такая утилитатранслятор. И язык ассемплера — это не такой язык
3:16
программирования, как мы понимаем, Pthon или C, а очень низкоуровневый, то есть
3:21
близкий к железу. А в пятидесятые года у каждой модели компьютера был свой ассемблер со своим синтаксисом,
3:28
специфичным именно для этой самой модели компьютера. Позже, в шестидесятых годах начали появляться стандарты ассемблеров
3:34
под конкретной архитектуры и операционные системы, но уже с начала сороковых годов стали создавать
3:39
различные прототипы ассемблеров. А к середине пятидесятых появились зрелые ассемблеры, такие как САП на компьютере
3:46
IBM 704, который поддерживал мненики. То есть вместо числовых кодов, как на этой
3:52
картинке, можно было писать символьные коды, вот как на этой картинке. А также
3:57
были добавлены метки, то есть так помечали участки кода, куда нужно перепрыгнуть, если такая метка
4:03
попадётся. Код в компьютер загружался с ленты. С одной ленты в компьютер загружался сам ассемблер, его код. Он
4:10
записывался в память и запускался. По сути, этот процесс аналогичен тому, как при старте компьютера загружается
4:16
операционная система. Далее, с отдельной лентой или с перфокарты, которую тоже совали в этот компьютер, уже Ассемблер
4:23
считывал исходную символьную программу. Асмблер компилировал код, то есть
4:29
преобразовывал команды в машинный код в нолике единички. Надо отметить, что у компьютеров того времени не было ни
4:34
жёстких дисков, ни клавиатур и ни мониторов. Тем не менее, он делал вычисления, и данные в него вносили на
4:41
перфокартах, а результат вычисления печатались на принтере. Либо вот так вот загоралась какая-то лампочка. Вот на
4:47
фото человек играет в шахматы. Видимо, автор фото хотел сказать, что компьютер как-то ему в этом помогает. Ну либо
4:53
компьютер с ним играет в шахматы. А вот так выглядел код. Сначала его печатали на печатащей машинке, на ручной такой,
5:00
либо вообще писали от руки. А потом операторы на специальных Kpunch машинах
5:05
проделывали дырки в перпокарте, которые как бы отражали этот код. Их подгружали в компьютер, и он мог выполнять этот код
5:12
или даже мог распечатать его на линейном принтере. То есть компьютер мог, считывая формат Perfкар, преобразовывать
5:18
код обратный в текстовый формат. И в результате вы можете полюбоваться на этот код, распечатанный на принтере без
5:24
монитора. Тогда мониторов ещё не было. Этот код переносили на перфокарты. В определённые поля записывались различные
5:31
типы инструкции или данные. А вот так выглядит 5 Мб. Это типа как одна
5:37
фотография нормального качества в вашем телефоне. А вот фотография склада Perfокарт. И это приблизительно как
5:42
жёсткий диск вашего компьютера.
Самый лучший симулятор коммерческой разработки
5:48
А вы знаете про наш курс симулятор коммерческой разработки jango.run? С ним вы гарантированно улучшите свои навыки
5:54
программирования. И вот почему. В этом курсе вы пишите [музыка] код, а мы его проверяем. Это курс симулятор. И всё,
5:59
что от вас требуется — это программировать. Много программировать. Вы попадаете на работу в компанию Startup и будете разрабатывать ээнд для
6:06
одного мобильного приложения. Директор выдаёт вам задание, старший программист объясняет вам теорию, а вы пишете код.
6:13
Наша система автоматических проверок будет проверять каждую деталь вашего кода и просто не пропустит вас на
6:19
следующий уровень, если вы что-то сделаете не так и код не заработает. Вы буквально будете работать программистом
6:24
в нашем симуляторе. Всё как на работе в настоящей компании, но с одним отличием. В нашей компании также работает e и
6:30
ментор, и он будет подсказывать, если у вас что-то не получится или появятся какие-то ошибки, с которыми вам сложно
6:36
справиться. Так что вы не останетесь один на один с вашим кодом, а всегда будете получать обратную связь. А если
6:41
встретите ошибку, получите подробное указание, как её исправить. Вы будете писать эээнд для приложения, у которого
6:47
уже есть красивый фронд, и с каждым выполненным заданием будут открываться новые компоненты на сайте, и приложение,
6:53
которое вы развиваете, будет как бы оживать. А по окончанию курса вы получите персональное видео кодрев от
6:59
меня, где я проверю, насколько ваш код соответствует лучшим практикам программирования. В результате это самое
7:05
приложение на хостинге вы получите к себе в портфолио вместе с бэкэндом и фронтэндом. А цену на наш симулятор мы
7:10
постарались сделать максимально доступной. Заходите на наш сайт jango. И попробуйте свои силы в симуляторе
7:16
коммерческой разработки.
Разбор кода Assembler
7:21
Давайте разберём вот такой пример кода из инструкции к компьютеру IBM 704.
7:27
Это пятьдесят седьмой год. Это пример достаточно раннего кода для ассемблера.
7:32
Ну и когда классические языки программирования, они ещё только зарождались. Давайте сразу переместимся
7:38
на страницу 116. Вот такие вот буквенные трёхсимвольные обозначения.
7:45
Это называется монемоники. То есть это такие как бы псевдонимы для процессорных
7:51
а команд, которые писались числами. Ну вот и, собственно, до до ассемблера
7:56
приходилось писать именно числами команды для процессора. Вот здесь их заменили на буквенные, что гораздо
8:02
удобнее читается и запоминается. Так вот, что делает этот код? Задача у этого
8:08
кода стоит такая: надо сравнить некоторые данные с контрольной суммой и
8:15
в зависимости от результата, значит, остановить выполнение кода на error либо на good. Вот в этом месте, да, у нас
8:22
есть error и good. И здесь мы разберём, как делались условные переходы на языке
8:28
ассемблера. Ну, опять же, это не какой-то конкретный язык, да? То есть их было много реализаций, там могло
8:33
делаться по-разному. Под каждую, э, компьютер изначально писали там свою версию ассемблеры, только потом всё это
8:40
стандартизировалось. Ну, для начала немножко тоже из истории. Вот в ранних компьютерах типа IBM 704, э, нельзя
8:49
просто было взять и сравнить два числа в памяти. Значит, мы должны были одно из них положить в аккумулятор. Это такой
8:56
некий железный регистр на вакуумных лампах. Вот так вот. И вот, а тогда уже,
9:03
если значение какое-то лежит там, то его можно было сравнить с чем-то, что хранится в памяти. Ну и этот
9:09
аккумулятор, он использовался как бы для разных малепуляций с данными. То есть там, чтобы с ними сравнивать, чтобы
9:15
инкрементировать, чтобы там, не знаю, делить, умножать, вот приходилось класть в такую специальную для этого ячейку. Ну
9:22
и теперь пройдёмся по командам. Я их я их все разобрал, но я сконцентрирую ваше внимание только на нескольких из них
9:28
самых показательных и интересных, на мой взгляд. Вот, допустим, команда DXD2.
9:36
Это означает, что нам нужно создать ячейку с именем DA в памяти по адресу
9:42
- То есть это указатель в памяти. И это вот пример такой прямой мапуляции с
9:47
памятью. Мы в следующих языках будем немножко про это говорить. Значит, команда CID означает copy and add. И что
9:55
она делает? Она считывает значение из внешнего накопителя. В данном случае это
10:00
магнитный барабан, и прибавляет их в аккумулятор. И вот похожую вещь делает
10:07
команда а CPMI. Только она копирует значение с внешнего накопителя, но уже
10:13
не не в аккумулятор кладёт, а она м это копия, она их копирует в ячейку с именем
10:19
temp. Ну и вот, чтобы разобраться с тем, как делались условные переходы в
10:24
ассемблере, а давайте посмотрим на команду CAS, да, CAS. Это означает
10:31
compare accumulator with storage. Значит, для начала чуть-чуть истории, да? Вот в пятидесятых годах ещё не было
10:37
привычных нам ифов, да, вот этих условных переходов с синтаксисом if else. В те времена использовался
10:44
условный переход, который назывался Freeway Conditional Transfer. И вот здесь он, значит, реализован. Как
10:50
работает эта команда? А, значит, аккумулятор VI storage. То есть вот сюда
10:56
мы передаём ячейку — это ячейка в в памяти, это в сторедже. И с чем
11:03
сравнивать? Ну, с тем, что в аккумуляторе. То есть здесь это уже подразумевается, да? То есть мы всего
11:08
лишь одно значение в эту команду передаём, и она будет сравнивать с тем, что уже есть, что накоплено в этом
11:13
аккумуляторе. И значит, если значение в аккумуляторе меньше, чем темп, тогда мы
11:18
прыгаем на следующую строчку. Если значение в аккумуляторе равно тому же, что и в ячейке, мы прыгаем
11:25
через строчку вот сюда, значит, в на. И если значение в аккумуляторе больше, вот
11:31
мы будем прыгать через две строчки вот сюда вот. Вот так были реализованы
11:36
условные переходы в ассемблере и как бы ещё до изобретения ранних классических
11:42
языков, таких как фортран, кабол там или алгол. Ну и вот интересный пример, да,
11:47
как можно сделать условный переход, не используя if. Вот таким вот способом. А,
11:53
ну и, кроме того, в этом коде есть ещё и обход цикла. И вы ни за что не догадаетесь, как он тут реализован. Это
11:59
очень необычно, но я не буду про него рассказывать. Если интересно, сделайте скриншот и попросите вот искусственный
12:06
интеллект вам объяснить, как в этом входе, в этом коде реализован обход цикла. А мы пойдём дальше.
Классические языки программирования
12:17
В пятидесятые годы на ассемблерах в основном программировали инженеры учёные, которые создавали первые
12:22
программы для научных расчётов. Как вы могли заметить по предыдущим фотографиям, компьютеры были довольно крупные. Пятидесятые и шестидесятые года
12:29
- это была эпоха мейнфреймовов. Работали на таких компьютерах в основном учёные, и стояли они в учислительных центрах или
12:36
в университетах, в научно-исследовательских институтах и в крупных коммерческих компаниях. А в конце пятидесятых и в начале
12:42
шестидесятых годов появляются первые мощные языки программирования. Асэсемблер был слишком завязан на
12:47
железе, и возникала необходимость сделать программирование более абстрагированным от устройства компьютера, а программы более
12:54
переносимыми, то есть, чтобы была возможность запускать программы на разных моделях компьютеров. Научные расчёты массово ушли в Ford Run, который
13:00
стал де-факто стандартом в науке. Бизнес вчисления всё больше доминировал Кабул, а вот операционные системы и
13:07
аэрокосмические расчёты всё ещё писали на языке ассемблера. Следующие языки фартра, Кабол и Алго — это будут
13:14
процедурные языки программирования. Они воспринимают программу как последовательность шагов с переходами
13:19
между частями кода. То есть единицей программы являются процедуры либо функции. Разница между ними в том, что
13:25
функция выполняется и возвращает значение, а процедура — это просто блок кода после выполнения не возвращает
13:31
ничего, но может делать разные побочные эффекты. К примеру, менять глобальные переменные.
Fortran
13:41
Фортран как раз создавали, чтобы уйти от ассемблера в научных задачах. Язык разрабатывала команда IBM под
13:47
руководством Джона Бекуса. Они сделали то, во что тогда почти не верили. компилятор, который выдаёт код по
13:53
производительности, почти не уступающей рукописному на ассемблере. Компьютеры в то время были достаточно медленные, и
13:59
сделать высокоуровневый язык, который довольно хорошо скомпилировался в язык ассемблера, была задача непростой.
14:05
Фортран — это первый высокоуровневый язык, который активно применялся всю вторую половину XX века и даже начало
14:11
XXI века. И всё математическое знание, которое имело человечество, оно перевело именно в программный вид на языке
14:18
фартран. Любая функция, всё что угодно из высшей математики, вы там найдёте. Создатель фортрана Джум Беку сказал, что
14:23
язык он изобрёл отли, потому что задолбался писать на ассемблере. Основная цель команды разработчиков
14:29
языка было упрощение ввода уравнений в компьютер. Язык FTR активно использовался в научных вычислений и
14:35
пережил много реинкарнаций и активно использовался в шестидесятые и семидесятые года. а кто-то и пользуется
14:41
им до сих пор. А что важно для истории и программирования, что фартран — это первый высокоуровневый язык и что он
14:47
заложил основу переносимости и стандартизации. К середине шестидесятых годовран стал первым национальным
14:53
стандартом и работал на множестве платформ. И это редкость для того времени.
Разбор кода Fortran
15:01
А вот в этом примере кода давайте мы посмотрим, как делались циклы на раннем фортране. Со временем как бы этот
15:08
синтакс отменялся, но для истории программирования нам интересно вот как выглядели классические языки
15:14
программирования в то время, когда их активно использовали. А давайте посмотрим. Это архивный документ NASA.
15:20
Какая-то программа для отделения частей крыльев. Что-то из астронавтики.
15:26
Вот. Сразу извиняюсь за качество скана. Так как документ довольно старый и что-то могло не пропечататься, ну, я
15:32
буду всё это пояснять, конечно. Давайте вот посмотрим такой фрагмент
15:38
кода на странице 20. Значит, для начала давайте посмотрим, как здесь написан
15:43
условный переход. Вот, значит, а if в скобочках из топ 3
15:49
то и Q точка о, да, go to 8. Вот go to — это очень типичная конструкция для того
15:57
времени, для ранних языков. Это переход пометки. То есть вот если вот это
16:03
условие удовлетворяется, тогда мы прыгаем на метку восемь. Ну, условие это это переменная, да, вот такой синтаксис
16:10
точка и Qточка. Так само если она равна единице, тогда прыгаем на метку восемь. А давайте посмотрим, где же эта метка
16:17
восемь находится. Вот мы сюда спустимся и вот где-то она, да, вот эта метка
16:23
восемь. Значит, а что, собственно, она делает? Она делает print 9 и делает go
16:29
to на метку 20. Так, давайте посмотрим, где у нас метка 20. Где-то она была
16:35
наверху, я помню. Вот она. Угу. Здесь мы тоже что-то делаем, да? Какой-то if.
16:40
Если этот if, тогда мы идём вот сюда вот. М, то есть на 21 — это следующая за ней метка. Ну, короче говоря, вы поняли,
16:47
да? То есть эти метки, они располагаются не друг за дружкой по какому-то порядку,
16:53
да, они достаточно рандомно вот так вот здесь набросаны. И вот данный пример кода, он всего на четыре страницы А4 в
17:01
больших программах, да, вот такие прыжки по меткам было отслеживать, конечно, очень неудобно. И, ну, всё вот
17:08
классическое как бы программирование пятидесятых-шестидесятых годов, они писались в основном именно
17:14
так, вплоть до перехода к структурному программированию. Ну, о нём мы поговорим немножко позже. А сейчас давайте
17:20
рассмотрим пару интересных моментов в этом коде. Вот для начала здесь
17:26
нам видно вызов процедуры. Вот call loop 3 в скобочках из top 3. Вот это вот переменная, которые мы рассматривали
17:32
только что. Call — это вызов процедуры, да, название процедуры, и в скобочках в неё передаётся аргумент. Ну такой вот
17:40
достаточно а простой синтаксис. Это характерно вообще для процедурного программирования, где единицей программы
17:47
являются процедуры или функции. Вот. Ну, разница в том, что функция, она возвращает значение, а процедура она не
17:54
имеет возврата. Вот. И, значит, самое интересное, что в этом коде мм можно
17:59
увидеть — это то, как тут делаются циклы. Вот посмотрите, здесь написано
18:04
30, да? И что это значит? О том, что отсюда запускается цикл. Вот на
18:11
следующие строчки, вот эти вот три. И цикл идёт вплоть до метки 30. Вот метка
18:17
Вот. Ну включительно. То есть вот это, это и вот эта строчка 30 тоже
18:23
является частью цикла. То, что за ней уже циклом не является. То есть вот это вот до 30
18:29
обозначает границу мм как бы кода для этого цикла. Дальше у нас идёт и равняется 1. То есть
18:37
тут мы как бы ставим с какого значения нам нужно считать итерацию. Вот. И это и
18:43
оно будет с каждым проходом а по этому циклу оно будет
18:49
инкрементироваться на единицу. Запятая n. Как только i станет больше,
18:56
чем n, эт цикл прекратится. Вот такой вот интересный синтаксис. То есть это
19:01
означает то, что код будет выполняться вот, значит, отсюда и до метки 30 включительно. С каждым разом i будет
19:07
увеличиваться на единицу, пока i не станет больше n. И когда вся эта история закончится, просто код переходит на
19:14
следующую строчку, то есть вот на вызов вот этой процедуры. Вот так вот интересно выглядели циклы на
19:21
фортране. Немножко странно, да, если сравнивать с современными языками программирования, но вот такой синтаксис
19:27
в Фортране, он сохранялся вплоть до девяностых годов. Да, версии Fortr 90.
19:33
То есть, ээ, более 30 лет циклы писали именно таким образом на Фортране.
COBOL
19:43
В 1959 году изобрели Кабол в комитете кода сил. Вдохновляла и продвигала идею
19:50
Грейс Хоппер. Цель — сделать деловые бухгалтерские и финансовые программы читаемыми для людей и переносимыми между
19:57
машинами. И вот такая особенность языка Кабallл, что программа написана как будто бы на естественном языке. Он
20:02
создавался, чтобы финансовые менеджеры могли пользоваться компьютером и программировать как бы словами, так как
20:08
визуальных средств работы с компьютером тогда ещё не было, потому что не было мониторов и не было персональных компьютеров. На практике прикладные
20:14
аналитики и программисты писали код, а менеджеры обычно читали спецификации и отчёты. И читаемость кода для
20:21
непрограммистов тут была ключевой. На этой картинке заполненные от руки карточка с кодом Кабол, которые потом
20:27
перенесут на перфорты и потом отправят её выполняться в компьютер. Язык Кабул оказался невероятно популярным. В
20:33
шестидесятые и семидесятые года он распространился по всем госучреждениям и финансовым организациям США и оказался
20:39
невероятно живучим. Ближе к концу этого видео мы ещё про него скажем два слова.
Разбор кода COBOL
20:49
И для примера кода на языке Кабол. Давайте рассмотрим сейчас парочку
20:54
документов. Вот вот это спецификации для языка Кабол шестидесятого года. Мы
21:01
откроем последние страницы, и здесь будут зарезервированные слова.
21:07
Вот это список, значит, зарезервированных слов. Тут их более 200
21:13
вот в этих вот на этих двух страницах. Для примера в Питоне 35 зарезервированных слов. А теперь давайте
21:20
посмотрим вот на этот документ. Это спецификации программирования на Каболе на компьютерах IBM 1401, 1440, ну и так
21:28
далее. Значит, переместимся на страницу 52. Посмотрите на сам код. Вот справа
21:35
слева этот, скажем, служебные метки. На них можно внимания не обращать. Вот. И,
21:41
значит, сам код он уже как бы задаёт такую некую структуру. Сверху у нас идёт
21:48
division. Значит, это название программы и разные служебные комментарии. Значит,
21:53
потом environment division, это некоторые настройки для мейнфрейма, на котором программу запускали, там какие
22:00
файлы использовать и прочее. Потом working storage division. Здесь обозначаются, какие м рабочие переменные
22:06
в памяти будут использованы. Ну и вот ниже процедур Division — это как раз то,
22:11
что нам интересно, это определение процедур, да? Ну, собственно, сам код, который будет исполняться. Вот в этом
22:18
коде тоже есть цикл, и написан он в стиле алгола, то есть таким естественным человеческим языком. А вот эта
22:25
программа, она вычисляет зарплату сотрудникам. Это довольно типичная задача для Алгола, так как это язык для
22:31
бизнеса. И вот снизу мы видим, значит, процедуру с названием Calculations. И на первой строчке она работает с переменной
22:38
Weekly Pay. Вот этот значок решётка — это не комментарии, как это в
22:43
Питоне там делается. Это просто особенности принтера, на котором этот код печатали. У него не было знака равно
22:49
и вместо него, значит, принтер печатала решётка. Поэтому это я так понимаю, оператор мм сравнения. Дальше, значит,
22:58
здесь написано move weekly pay to weekly detail line. Эта команда move, она
23:04
обозначает просто присваивание. То есть нам нужно вот в переменную Weekly Pay
23:10
присвоить значение detail. Так интересно, присваивание
23:15
сделано не через какой-то знак, да, а через слово move. Ну, обычно для этого используют знак
23:22
равно, да, или там двоеточие равно в некоторых языках. Вот. Дальше команда
23:27
ADД, она означает сложение, да, вот что там к чему нужно прибавить, ну и так
23:33
далее. А теперь давайте посмотрим, в общем, какой интересный здесь синтаксис используется для обхода цикла.
23:39
Performulations varing monthly pay from 500 by 10 until
23:44
momly pay is greater than 1000. То есть, что буквально означает? Выполняя абзац,
23:50
начиная с значения Monflipay 500, после каждого выполнение увеличиваем Monflipay
23:56
на 10 и повторяй это, пока Monfay не станет больше 1.000. То есть это вот
24:03
буквально код, написанный на английском языке. Если вы хорошо знакомы с английским, я думаю, даже вот на слух вы
24:09
уже можете понять, что он делает. И вот что характерно для Кабола, ну и для
24:15
языков того времени, что это значение оно оно не передаётся в процедуру, а просто используется вот некое глобальные
24:21
переменная и меняется она тоже глобально, да? Вот она, эта переменная. Здесь её глобально задали. И вот здесь
24:28
мы, значит, обходим и её меняем. А дальше вот в процедуре test hash totals
24:34
здесь идут условные переходы. Значит, вот решётка это подразумеваем, да, что это равно, то есть это оператор
24:40
сравнения. Значит, if hash total counter weekly равен hash total of weekly pay
24:46
and да, если вот эта переменная равна вот этой, а также вот эта равна вот этой, тогда мы делаем move correct
24:54
message to output record. То есть вот в этом вот как бы output record мы просто
24:59
вкопируем значение переменной correct message. Вот. Otherwise это просто вот
25:05
то же самое, что и слово else, да? If else условные переходы. Вот здесь используется слово otherwise, которое в
25:12
английском обозначает то же самое. Вот в одном случае, то есть переместить
25:17
incorrect message, да, в output record. Ну и дальше after advising to lines, да?
25:24
То есть это команда для принтеров, что нужно отступить две строки и потом, значит, close solary file, закрыть
25:31
зарплатный файл, да, run, установить выполнение. Ну, буквально вот на английском языке программа написана. И
25:38
вот такой вот синтаксис. Он, можно сказать, что и сегодня довольно легко читается. Здесь нет вообще ни одного
25:44
знака, да, кроме вот знаков, допустим, деления и умножения, которые вот любому школьнику понятны. И вот такими лёгкими,
25:51
понятными, читаемыми программы могли быть уже в пятидесятые, в шестидесятые года.
ALGOL
26:01
В 1958 году европейцы выпускают Алгол 58. Команда Фортран опередили их всего
26:08
на год. Язык анонсировала группа учёных на конференции в Сюрихе. Из США был приглашён Джон Бекус, один из создателей
26:14
языка Фортрам, Джозеф Бекстейн, который через год с группой других учёных разработает Кабол. Позже к ним
26:21
подключился Джон Макарти, автор языка Лисп. Над реализацией компилятора Агол работал учёный программист Dra из
26:28
Голландии, один из создателей концепции структурного программирования. Об этом виде программирования мы ещё будем много
26:33
говорить. Собрались топовые ведущие и специалисты по программированию того времени. Они определили некий стандарт
26:39
языка алгол, который дальше ещё 2 года до шестидесятого года дорабатывался.
26:44
Была определена спецификация языков BNF, в которой была написана часть теории компиляторов. И что интересно, что в
26:51
этом стандарте столько всего напридумывали такого, что ещё не поддерживали даже компьютеры того времени. В США не было компьютеров,
26:58
которые поддерживали ввод и вывод 116 букв, входящих в стандарт Alгол, и не очень торопились делать поддержку, так
27:05
как уже был развит фартран и им не имело смысла тратить большие ресурсы на то, чтобы их компьютеры работали с этим
27:11
новым европейским языком. Тем не менее, Алгол хорошо поддерживался в Европе и в Советском Союзе. Это структурный язык.
27:17
Программа состоит из блоков. Каждый блок имеет начало и конец. Begin и end. Имеются подпрограммы. В языке были
27:24
окончательно сформулированы все основные структурноуправляющие конструкции, такие как витвления, циклы и счётчики. Но
27:31
вышло так, что язык разрабатывался больше теоретически. Стандарты определялись на конференциях, из-за
27:36
этого многое, что в него добавляли, в результате не пригодилось. А так как компьютеры этого времени были большие и
27:42
не очень производительные, то для лгол сразу же потребовалась оптимизация. В 1962 году опять собрался комитет
27:49
знаменитых учёных, который поставил цель создать сокращённый вариант алгол. И в течение 6сти лет они собирались и
27:55
обсуждали, что должно было войти в новый вариант языка. Программист и учёный Клаус Вирт и Чарльз Хорд предложили
28:02
достаточно минимальный вариант языка, который был в результате отклонён. Но именно этот вариант впоследствии был
28:09
переделан Виртом в язык программирования Паскаль, который стал одним из самых лидирующих языков своего поколения. В
28:15
1968 году, то есть прошло уже 10 лет с момента выхода первой версии, был выпущен новый вариант языка, который
28:21
назывался Агол 68. И он оказался настолько сложен, что даже опытные программисты затруднялись на нём
28:28
работать. И этот первый европейский язык программирования получился достаточно логичный и гибкий, но не слишком
28:34
практичный и не получил популярности даже в самой Европе, где уже достаточно быстро распространились американские
28:40
Фортран и Кабол, которые к тому времени уже успели обрасти разными полезными библиотеками. Несмотря на то, что проект
28:46
Алгол не удался, опыт его не оказался бесполезным, так как он повлиял на последующие языки и изложил основы
28:52
структурного программирования. условные переходы, они существовали ещё и в ассемблере, и в раннем в фортране. Но
28:58
вот современный бинарный if then else с ключевым словом else появился впервые в алгол 60. И за что действительно можно
29:06
благодарить Алгол, что он заложил основу для языка Паскаль, который стал мейнстримом программирования сразу на
29:12
несколько десятилетий, о котором я расскажу в следующей части.
Разбор кода ALGOL
29:21
Вот этот документ — это код компилятора Алгол, написанный на Алголе.
29:28
Давайте посмотрим вот здесь фрагмент на странице 32. Я пытался найти какую-то
29:33
вот более прикладную программу, но в исторических примерах в нём в основном
29:39
какие-то очень абстрактные вещи. И вот этот пример кода мне показался достаточно красивым и интересным. Это
29:46
Lexer. Это такая первая стадия компилятора, где он читает исходный код
29:52
посимвольно. Вот тот код, который ему передаётся в компилятор. И вот та часть кода, которую мы сейчас
29:58
разберём, а она проходит по всем символам, пока в строке не встретит знак
30:05
точка запятую, что означает конец комментария. Вот. И таким образом, как
30:11
бы компилятор Алгола, он отделяет полезный код от комментариев. Вот
30:16
посмотрите на этот код. Он уже напоминает вообще современный язык программирования. Всё так неплохо в нём
30:22
организовано. В этом коде вы можете видеть много begin и end, да? Вот begin это
30:29
такой универсальный блок. А-э, если нам нужно написать какое-то выражение внутри, допустим, вот этого zна, который
30:37
вместе с ифом или внутри else, а, или внутри for, да, тогда мы отмечаем как бы
30:43
начало и конца блока как begin и end. То есть, если вот какое-то условие, да, вот
30:48
здесь написано условие, тогда и вот начинается begin, то есть вот этот блок кода. Ну, в современных языках для этого
30:55
чаще используют скобки или фигурные скобки. Ну, и здесь это читается достаточно легко, да.
31:01
со словами begin и end. Давайте разберём первое здесь выражение. Вот next 0 — это
31:09
метка. А метка, которая стоит вот на этом блоке кода. И позже на эту метку
31:15
будут переходы. Вы это увидите. Значит, дальше. А символ двоеточие равно сток
31:21
больше нуля. Then stock else next basic symbol. Это односрочное выражение.
31:28
двоеточее равно здесь это оператор присваивания. Значит, если переменная
31:34
сток 1, она больше нуля, тогда в переменную символ мы присвоим значение
31:41
сток 1, да? А в онлам случае мы вызываем процедуру next basic symbol. Тут вообще
31:48
название функции, оно должно быть слитно. Вот это вот три слова, это должно быть одним словом, потому что это
31:55
вот это вызов функции. Видимо, в этом документе специально так
32:00
напечатали код, чтобы нам с вами было читать удобнее. Вот спасибо им за это.
32:05
Ещё здесь небольшая путаница с терминами. А вот в объявлении функции написано integer procedure
32:13
next symbol. Ну, по сути, это именно функция, а не процедура, потому что она
32:19
возвращает значение. Просто эти термины, они тогда ещё только формировались. И вотгол процедурами называют как бы и
32:26
функцией, и процедуры. Давайте посмотрим код дальше. If last symbol равняется
32:32
семи колон. Вот такая галочка. Значит, last symbol равняется begin. Тут как раз
32:38
использованы обычные скобки для группировки выражения. знак равно — это оператор сравнения, а
32:47
вот эта вот галочка обозначает логическое или Сегодня было бы не очень
32:52
удобно программировать на алголе, так как у нас на клавиатуре просто нет таких символов, как вот эта вот галочка. Но в
32:58
те времена клавиатуры для программирования практически не использовались, поэтому у них с этим проблем не было. Тогда чаще
33:05
использовались перфокарты для ввода кода. А выражение выглядит достаточно просто. Значит, если а символ равен
33:11
семикон или если last symbol равен beginin, дальше вот эта вот галочка вверх а обозначает логическое и и символ
33:20
равен comment. И вот начинается блок код с и end. Он начинается с названием
33:26
метки. Skip 0 — это название метки. И дальше в переменную символ мы
33:32
присваиваем результат выполнения функции Next Basic Symbol. И дальше, если символ
33:40
не равен семикон, тогда мы делаем прыжок по метке скипнуль, то есть вот на ту же
33:47
самую метку, которую мы только что объявили вот здесь вот, и будем вот так вот ходить по кругу, пока символ не
33:54
будет семи колонк. То есть он читает код посимвольно до тех пор, пока не встретит точку с запятой и тогда прыгает на метку
34:00
next, то есть вот на эту вот метку. И почему здесь код зациклен при помощи
34:06
прыжка на метку, которую мы только что объявляли? А сделано это потому, что в алголе не было оператора while или
34:13
оператора там repat until? То есть нельзя было написать прямой цикл и как
34:18
бы зациклить это выражение. И вот для этого здесь используется goto to и прыжок пометки, чтобы зациклить этот
34:25
код. Вот в следующем языке вы увидите, а как это могло бы быть реализовано по-другому. И как вы видите, язык алгол,
34:32
он достаточно читаемый. И вот он нам кажется таким по той причине, что он повлиял много и на последующие поколение
34:39
языков программирования. К примеру, Алгол повлиял на язык ABC, а ABC повлияло на Python. А Python уже, ну,
34:46
многие очень хорошо понимают. И вот такая вот хорошая читаемость кода и хорошая организация кода- это во многом
34:53
именно алголовская традиция.
Pascal
35:00
В 1970 году Клаус Вирт, программист, входивший в комитет учёных, создававших
35:05
язык алгол, разработал свой язык Паскаль. Паскаль создавался для обучения программированию. Как и Алгол — это
35:12
структурный язык программирования. Он не был так перегружен, как алгол. Цель была построить простой язык с небольшим
35:18
набором функций. В основе языка строгоя типизации, о ней мы поговорим чуть позже, и опора на структуру, то есть на
35:25
структурное программирование. Это вир считал полезным для обучения студентов. В структурном программировании
Структурное программирование
35:30
использовались последовательность, ветвления и циклы. Давайте немного на них остановимся. Последовательность —
35:35
это выполнение операторов один за другим. А = 1, b = a + 2, print b.
35:41
Ветвление — это выбор одной из альтернатив по условию. If x > 0, print
35:47
x, else, print y. Цикл — это повторение блока кода несколько раз. For e, inlist
35:53
и так далее. Таким образом, логику можно было разместить в коде более структурированно в противоположность
35:59
тому подходу, который был в Фартране или в Коболе, где часто использовали просто прыжки по меткам через G2, что делало
36:05
код более хаотичным. И следующее поколение языков, таких как Паскаль, больше опирались на структурное
36:12
программирование, чем на переходы по меткам. Теорема Бома Якопини показывает:
Теорема Бема-Якопини
36:17
любой детерминированный алгоритм можно выразить комбинацией последовательности, ветвления и цикла. Эта теорема — это
36:23
фундамент структурного программирования. Во многом на этот процесс повлияло и распространение клавиатур, что ускорило
36:29
принятие идей структурного программирования. Код стало удобно редактировать и компилировать интерактивно, а не перекладывать колоды
36:37
факар, как это было раньше. Так вот, идеи структурного программирования, такие как блочная организация кода и
36:42
использование ограниченного набора конструкций, последовательность, метвления и циклы была реализована уже в
36:48
Alгол 60. И Алгол, как мы знаем, создал много стандартов, но не был хорош для практического программирования в
36:54
университетах. Так вот, Паскаль упростил идеи структурного программирования и сделал их массовыми. Паскаль
37:00
использовался для обучения в университетах и в семидесятых-восьмидесятых годах. И из учебного программирования он перетёк в
37:06
коммерческое. Впоследствии восьмидесятые и девяностые на нём писали и приложения для MacOS, и файловые менеджеры, и даже
37:13
игровые движки. Язык получился достаточно неплохой и упорядочный и много всего умел. Язык получил большое
37:19
распространение в восьмидесятых, и в девяностых, и даже в начале дх000чных, но об этом чуть позже.
Разбор кода Pascal
37:29
Давайте рассмотрим код из руководства к языку Паскаль 1978
37:35
года. Так вот, я открою страницу 150. И, значит, что это за код? А этот код на
37:42
Паскале — это алгоритм рисования отрезка на растровом экране. Это такой
37:48
пиксельный чёрный-белый экран. Вот аналогич таким, который сегодня ставят
37:53
на электронные книги. К примеру. Смысл этого кода в том, чтобы рисовать линии на отрезки. А так как экран пиксельный,
38:01
и на нём ровные линии могут быть только абсолютно горизонтальные или вертикальные, а вот те, что между ними,
38:07
да, наклонные линии, диагональные линии, они будут как бы из-за пикселей они
38:12
будут идти зигзагом или такими зубчиками. И вот смысл этого кода в том, чтобы рисовать наклонные линии по
38:19
пикселям максимально гладко. Ну и сразу видно хорошая хорошая организация кода.
38:25
Вот сверху идёт объявление процедуры. Главная процедура — это вот du line, то
38:31
есть рисование линии. Она принимает аргументы. И вот аргумент
38:37
дельта Y, дельта X и in. Это про них мы будем сейчас немножко говорить. Здесь в
38:42
этой процедуре идёт объявление переменных. Вот здесь. И дальше идёт как бы объявление, а, вложенных в неё
38:48
процедур. Мы также в этом коде видим вот эти вот, э, блоки begin и end. Это то,
38:56
что пришло в Паскале из Алгола. И также, как и в Алголе, здесь может быть как бы
39:02
один begin end включен внутрь другого begin. И язык, он это понимает, да, что
39:08
когда мы идём вот по этому бегину и доходим до этого энда, он понимает, что это end для вот этого вложенного цикла,
39:15
для вложного блока begin, а не для внешнего. А вот здесь вот снизу
39:22
begin и end с комментарием Drew Line, это, собственно, тело главной процедуры,
39:29
то есть выше были объявления вложенных процедур, а вот это вот само тело вот этой вот главной процедуры. И что
39:36
интересно, вот здесь вот условие: if дельта x > дель y, тогда do for x в ином
39:43
случае else, да, do for y. То есть тут мы как бы сравниваем величину дельту и
39:49
дельту и какая из них больше м вертикальная либо горизонтальная. В зависимости от этого
39:55
код выбирает, какую а процедуру ему использовать для рисования этой линии.
40:00
Вот здесь написано do for x для более горизонтальных. И вот do for y для для
40:06
более вертикальных линий. И вот сам такой подход как бы мм выбора процедуры
40:12
в зависимости от параметров это уже выглядит достаточно современно. Это такой выбор стратегии, что
40:18
показывает довольно хороший дизайн кода. И на более ранних языках это скорее сделали бы через if и через прыжок
40:25
наметку go to. А здесь это сделано вот через if и выбор процедуры так в одной
40:32
строчкой вот в таком вот условии. Ну, допустим, мы переходим на процедуру do for x. Что мы здесь видим? Вот, а,
40:40
значит, repeat и until I равняется нулю. Это и есть прямой цикл, то есть блок
40:47
кода, который будет постоянно повторяться до тех пор, пока и не станет нулём. То есть, так как мы вычитаем уи с
40:54
каждой итерацией по единичке, то рано или поздно он станет нулём. Ну, если, конечно, и изначально не был минусовым.
41:00
Ну, я думаю, здесь это тоже предусмотрено. Так вот, то, что мы разбирали в кодел в
41:07
прошлый раз, что им приходилось делать такой прыжок пометки goto, потому что в языке ещё не было конструкции while, да,
41:14
то вот в Паскале переходы по меткам вы уже не найдёте, потому что вот есть
41:20
такой repeat анти, и через него можно сделать такой вот прямой цикл без
41:26
прыжка по меткам. И тут же в этом цикле мы вызываем процедуру Drew Dot. Вот она
41:31
чуть выше. И в ней м вы видите конструкцию switch case. Есть переменная
41:37
ink, в которой определяется выбор чернила. Белое там либо чёрные, либо
41:43
радар. Ну радар — это вообще не чернила, а это такая специальная функция для определения расстояний. Ну сейчас нам
41:49
это неважно. И вот этот sвиtchйс, он впервые, собственно, появился в Алголе
41:54
И многое вообще из того, что здесь есть, оно уже появилось в Алголе. Вот, допустим, вложенные процедуры.
42:02
Или когда мы вызываем процедуру DRW do dot внутри процедуры do for X, хотя она
42:07
объявлена снаружи. Вот эта вот процедура, да, она объявлена не внутри этой процедуры, а она как бы она
42:14
находится уровнем выше. Ну, мы её видим, потому что это мм лексическая область
42:19
видимости. То есть функция видит а внешние переменные, а вот вне этой
42:25
функции не будут доступны переменные, объявленные внутри этой функции. Да, вот
42:31
Dot — это внешняя переменная. А если мы внутри неё объявили error, то она будет
42:37
доступна вот только внутри вот этого вот блока begin. Это тоже появилось в Алголе
42:43
и пришло оттуда в Паскале. В противоположность тому, как это было в ранних языках, про которые мы говорили,
42:48
вот фартран или Кабол, когда как бы все переменные были по сути глобальные и
42:54
процедуры могли их просто менять глобально. Ну, а по сути Паскаль — это такой алгол плюс структурный подход,
43:02
когда программа представляет собой комбинацию последовательность ветвлений и циклов, а, перехода по меткам goto.
43:09
Ну, они тоже существуют в Паскале, но ими как бы крайне не рекомендуется пользоваться, потому что вот сам язык,
43:16
его философия подразумевает структурное программирование.