Просмотр кода страницы Язык программирования

{{чистить|дата=2023-01-08}}
{{много внутренних ссылок|дата=2023-01-08}}
'''Язы́к программи́рования''' — [[формальный язык]], предназначенный для записи [[Компьютерная программа|компьютерных программ]]<ref name="ISO24765">ISO/IEC/IEEE 24765:2010 Systems and software engineering — Vocabulary</ref><ref name="ISO2382">ISO/IEC 2382-1:1993, Information technology — Vocabulary — Part 1: Fundamental terms</ref>. Язык программирования определяет набор [[лексика|лексических]], [[синтаксис (программирование)|синтаксических]] и [[семантика (программирование)|семантических]] правил, определяющих внешний вид программы и действия, которые выполнит исполнитель (обычно — [[Электронно-вычислительная машина|ЭВМ]]) под её управлением.

Со времени создания [[История вычислительной техники#1835—1900-е: первые программируемые машины|первых программируемых машин]] человечество придумало более восьми тысяч языков программирования (включая [[Эзотерические языки программирования|эзотерические]]). Каждый год их число увеличивается<ref>{{Статья|ссылка=https://www.scienceopen.com/hosted-document?doi=10.14293/S2199-1006.1.SOR-.PP5RV1O.v1|автор=Sammar Qayyum, Saqib Ali|заглавие=A Pragmatic Comparison of Four Different Programming Languages|год=2021-06-21|издание=ScienceOpen Preprints|doi=10.14293/S2199-1006.1.SOR-.PP5RV1O.v1|archivedate=2023-06-10|archiveurl=https://web.archive.org/web/20230610142906/https://www.scienceopen.com/hosted-document?doi=10.14293/S2199-1006.1.SOR-.PP5RV1O.v1}}</ref>. Некоторыми языками умеет пользоваться только небольшое число их собственных разработчиков, другие становятся известны миллионам людей. Профессиональные [[программист]]ы могут владеть несколькими языками программирования.

Язык программирования предназначен для написания компьютерных программ, которые представляют собой набор правил, позволяющих компьютеру выполнить тот или иной [[вычислительный процесс]], организовать управление различными объектами, и т. п. Язык программирования отличается от [[Естественный язык|естественных языков]] тем, что предназначен для управления ЭВМ, в то время как естественные языки используются, прежде всего, для общения людей между собой. Большинство языков программирования использует специальные конструкции для определения и манипулирования [[Структура данных|структурами данных]] и управления процессом вычислений.

Как правило, язык программирования определяется не только через спецификации ''стандарта языка'', формально определяющие его [[синтаксис (программирование)|синтаксис]] и [[семантика (программирование)|семантику]] {{переход|#Стандартизация}}, но и через ''воплощения (реализации) стандарта'' — [[программные средства]], обеспечивающие [[Транслятор|трансляцию]] или [[Интерпретатор|интерпретацию]] программ на этом языке {{переход|#Компилируемые и интерпретируемые языки}}; такие программные средства различаются по производителю, марке и варианту (версии), времени выпуска, полноте воплощения стандарта, дополнительным возможностям; могут иметь определённые ошибки или особенности воплощения, влияющие на практику использования языка или даже на его стандарт.

== История ==
{{main|История языков программирования}}

=== Ранние этапы развития ===
Можно сказать, что первые языки программирования возникали ещё до появления современных электронных вычислительных машин: уже в [[XIX век]]е были изобретены устройства, которые можно с долей условности назвать программируемыми — к примеру, [[музыкальная шкатулка]] (и позднее [[механическое пианино]]) посредством металлического цилиндра и [[Жаккардовый ткацкий станок]] (1804) посредством картонных карт. Для управления ими использовались наборы инструкций, которые в рамках современной классификации можно считать прототипами [[Предметно-ориентированный язык программирования|предметно-ориентированных языков программирования]]{{нет АИ|8|01|2023}}. Значимым можно считать «язык», на котором леди [[Лавлейс, Ада|Ада Августа (графиня Лавлейс)]] в 1842 году написала программу для вычисления [[Числа Бернулли|чисел Бернулли]] для аналитической машины [[Бэббидж, Чарльз|Чарльза Бэббиджа]], ставшей бы, в случае реализации, первым компьютером в мире, хотя и механическим — с паровым двигателем.

В [[1930-е годы|1930]]—[[1940-е годы|1940 годах]] [[Чёрч, Алонзо|А. Чёрч]], [[Тьюринг, Алан|А. Тьюринг]], [[Марков, Андрей Андреевич (младший)|А. Марков]] разработали математические абстракции ([[лямбда-исчисление]], [[Машина Тьюринга|машину Тьюринга]], [[Нормальный алгоритм|нормальные алгоритмы]] соответственно) — для формализации [[алгоритм]]ов.

В это же время, в 1940-е годы, появились электрические цифровые компьютеры и был разработан язык, который можно считать первым высокоуровневым языком программирования для ЭВМ — «[[Plankalkül]]», созданный немецким инженером [[Цузе, Конрад|К. Цузе]] в период с [[1943 год|1943]] по [[1945 год]]ы<ref>[[Raúl Rojas|Rojas, Raúl]], et al. (2000). «Plankalkül: The First High-Level Programming Language and its Implementation». Institut für Informatik, Freie Universität Berlin, Technical Report B-3/2000. [http://www.zib.de/zuse/Inhalt/Programme/Plankalkuel/Plankalkuel-Report/Plankalkuel-Report.htm (full text)] {{Wayback|url=http://www.zib.de/zuse/Inhalt/Programme/Plankalkuel/Plankalkuel-Report/Plankalkuel-Report.htm|date=20141018204625}}</ref>.

Программисты ЭВМ начала [[1950-е годы|1950-х годов]], в особенности таких, как [[UNIVAC]] и IBM 701, при создании [[Программа (компьютер)|программ]] пользовались непосредственно [[Машинный код|машинным кодом]], запись программы на котором состояла из единиц и нулей и который принято считать [[Поколения языков программирования|языком программирования первого поколения]] (при этом разные машины разных производителей использовали различные коды, что требовало переписывать программу при переходе на другую ЭВМ).

Первым практически реализованным языком стал в 1949 году так называемый «[[Short Code|Краткий код]]», в котором операции и переменные кодировались двухсимвольными сочетаниями. Он был разработан в компании [[Eckert–Mauchly Computer Corporation]], выпускавшей UNIVAC-и, созданной одним из сотрудников Тьюринга, [[Джон Мокли|Джоном Мокли]]. Мокли поручил своим сотрудникам разработать транслятор математических формул, однако для 1940-х годов эта цель была слишком амбициозна. Краткий код был реализован с помощью [[интерпретатор]]а{{Sfn|Computer Languages|1989|loc = 1. Невидимый конструктор § Создание кодов, понятных человеку|страницы = 16}}.

Вскоре на смену такому методу программирования пришло применение языков второго поколения, также ограниченных спецификациями конкретных [[Компьютер|машин]], но более простых для использования человеком за счёт использования мнемоник (символьных обозначений машинных команд) и возможности сопоставления имён адресам в машинной памяти. Они традиционно известны под наименованием [[Язык ассемблера|языков ассемблера]] и [[автокод]]ов. Однако при использовании ассемблера становился необходимым процесс перевода программы на язык машинных кодов перед её выполнением, для чего были разработаны специальные программы, также получившие название ассемблеров. Сохранялись и проблемы с переносимостью программы с ЭВМ одной архитектуры на другую, и необходимость для программиста при решении задачи мыслить терминами «низкого уровня» — ячейка, адрес, команда. Позднее языки второго поколения были усовершенствованы: в них появилась поддержка [[Макрокоманда|макрокоманд]].

С середины 1950-х начали появляться языки третьего поколения, такие как [[Фортран]], [[Лисп]] и [[Кобол]]<ref>Linda Null, Julia Lobur, ''The essentials of computer organization and architecture'', Edition 2, Jones & Bartlett Publishers, 2006, ISBN 0-7637-3769-0, p. 435</ref>. Языки программирования этого типа более абстрактны (их ещё называют «языками высокого уровня») и универсальны, не имеют жёсткой зависимости от конкретной [[система команд|системы команд]] и конфигурации периферийных устройств. Программа на языке высокого уровня может исполняться (по крайней мере, в теории, на практике обычно имеется ряд специфических версий или диалектов реализации языка) на любой ЭВМ, на которой для этого языка имеется транслятор (инструмент, переводящий программу на язык машины, после чего она может быть выполнена процессором).

Обновлённые версии перечисленных языков до сих пор имеют хождение в разработке программного обеспечения, и каждый из них оказал определённое влияние на последующее развитие языков программирования<ref>{{cite web|url=http://www.oreilly.com/news/graphics/prog_lang_poster.pdf|format=PDF|title=History of programming languages|author=O'Reilly Media|accessdate=2006-10-05|authorlink=O'Reilly Media|archiveurl=https://web.archive.org/web/20080228004804/http://www.oreilly.com/news/graphics/prog_lang_poster.pdf|archivedate=2008-02-28|deadlink=yes}}</ref>. Тогда же, в конце 1950-х годов, появился [[Алгол]], также послуживший основой для ряда дальнейших разработок в этой сфере. Необходимо заметить, что на формат и применение ранних языков программирования в значительной степени влияли [[интерфейс]]ные ограничения<ref>Frank da Cruz. [http://www.columbia.edu/acis/history/cards.html IBM Punch Cards] {{Wayback|url=http://www.columbia.edu/acis/history/cards.html |date=20110513133237 }} [http://www.columbia.edu/acis/history/index.html Columbia University Computing History] {{Wayback|url=http://www.columbia.edu/acis/history/index.html |date=20110523183018 }}.</ref>.

=== Совершенствование ===
В период [[1960-е годы|1960-х]] — [[1970-е годы|1970-х годов]] были разработаны основные парадигмы языков программирования, используемые в настоящее время, хотя во многих аспектах этот процесс представлял собой лишь улучшение идей и концепций, заложенных ещё в первых языках третьего поколения.
* Язык [[APL (язык программирования)|APL]] оказал влияние на [[функциональное программирование]] и стал первым языком, поддерживавшим обработку [[Массив (программирование)|массивов]]<ref>Richard L. Wexelblat: ''History of Programming Languages'', Academic Press, 1981, chapter XIV.</ref>.
* Язык [[ПЛ/1]] (NPL) был разработан в 1960-х годах как объединение лучших черт Фортрана и Кобола.
* Язык [[Snobol]], разработанный и совершенствуемый в течение 1960-х годов, ориентированный на обработку текстов, ввёл в число базовых операций языков программирования [[сопоставление с образцом]]{{sfn|Пратт|1979|loc=4.6. Сопоставление с образцом|c=130—132}}{{sfn|Пратт|1979|loc=15. Снобол 4|c=483—516}}{{sfn|Пратт, Зелковиц|2002|loc=8.4.2. Сопоставление с образцом|c=369—372}}.
* Язык [[Симула]], появившийся примерно в это же время, впервые включал поддержку [[Объектно-ориентированное программирование|объектно-ориентированного программирования]]. В середине 1970-х группа специалистов представила язык [[Smalltalk]], который был уже всецело объектно-ориентированным.
* В период с [[1969 год|1969]] по [[1973 год]]ы велась разработка языка [[Си (язык программирования)|Си]], популярного и по сей день<ref>{{cite web|url=http://www.cs.berkeley.edu/~flab/languages.html|author=François Labelle|title=Programming Language Usage Graph|work=[[SourceForge]]|accessdate=2006-06-21|archiveurl=https://web.archive.org/web/20060617055109/http://www.cs.berkeley.edu/%7Eflab/languages.html|archivedate=2006-06-17|deadlink=yes}}</ref> и ставшего основой для множества последующих языков, например, столь популярных, как C++ и Java.
* В [[1972 год]]у был создан [[Пролог (язык программирования)|Пролог]] — наиболее известный (хотя и не первый, и далеко не единственный) язык [[Логическое программирование|логического программирования]].
* В [[1973 год]]у в языке [[ML]] была реализована расширенная система [[Полиморфизм (информатика)|полиморфной]] [[Система типов|типизации]], положившая начало типизированным языкам [[Функциональное программирование|функционального программирования]].
Каждый из этих языков породил по семейству потомков, и большинство современных языков программирования в конечном счёте основано на одном из них.

Кроме того, в 1960—1970-х годах активно велись споры о необходимости поддержки [[Структурное программирование|структурного программирования]] в тех или иных языках<ref>{{статья |заглавие=The Semicolon Wars |издание={{Нп3|American Scientist}} |том=94 |номер=4 |страницы=299—303 |язык=en |автор=Hayes, Brian |год=2006 |тип=magazine}}</ref>. В частности, голландский специалист [[Дейкстра, Эдсгер Вибе|Э. Дейкстра]] выступал в печати с предложениями о полном отказе от использования инструкций GOTO во всех высокоуровневых языках. Развивались также приёмы, направленные на сокращение объёма программ и повышение продуктивности работы программиста и пользователя.

=== Объединение и развитие ===
В [[1980-е годы]] наступил период, который можно условно назвать временем консолидации. Язык [[C++]] объединил в себе черты объектно-ориентированного и системного программирования, правительство [[США]] стандартизировало язык [[Ада (язык программирования)|Ада]], производный от [[Паскаль (язык программирования)|Паскаля]] и предназначенный для использования в бортовых системах управления военными объектами, в [[Япония|Японии]] и других странах мира осуществлялись значительные инвестиции в изучение перспектив так называемых языков пятого поколения, которые включали бы в себя конструкции логического программирования<ref>Tetsuro Fujise, Takashi Chikayama, Kazuaki Rokusawa, Akihiko Nakase (December 1994). «KLIC: A Portable Implementation of KL1» ''Proc. of FGCS '94, ICOT'' Tokyo, December 1994. http://www.icot.or.jp/ARCHIVE/HomePage-E.html {{Wayback|url=http://www.icot.or.jp/ARCHIVE/HomePage-E.html|date=20060925132105}} KLIC is a portable implementation of a concurrent logic programming language [[KL1]].</ref>. Сообщество функциональных языков приняло в качестве стандарта ML и Лисп. В целом этот период характеризовался скорее опорой на заложенный в предыдущем десятилетии фундамент, нежели разработкой новых парадигм.

Важной тенденцией, которая наблюдалась в разработке языков программирования для крупномасштабных систем, было сосредоточение на применении модулей — объёмных единиц организации кода. Хотя некоторые языки, такие, как ПЛ/1, уже поддерживали соответствующую функциональность, модульная система нашла своё отражение и применение также и в языках [[Модула-2]], [[Оберон (язык программирования)|Оберон]], Ада и ML. Часто модульные системы объединялись с конструкциями [[Обобщённое программирование|обобщённого программирования]]<ref>{{cite web|author=Jim Bender|url=http://readscheme.org/modules/|title=Mini-Bibliography on Modules for Functional Programming Languages|work=ReadScheme.org|accessdate=2006-09-27|date=2004-03-15|archiveurl=https://web.archive.org/web/20060924085057/http://readscheme.org/modules/|archivedate=2006-09-24|deadlink=yes}}</ref>.

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

В [[1990-е годы|1990-х годах]] в связи с активным развитием [[Интернет]]а распространение получили языки, позволяющие создавать сценарии для [[Веб-страница|веб-страниц]] — главным образом [[Perl]], развившийся из скриптового инструмента для Unix-систем, и [[Java (язык программирования)|Java]]. Возрастала также и популярность технологий [[Виртуализация|виртуализации]]. Эти изменения, однако, также не представляли собой фундаментальных новаций, являясь скорее совершенствованием уже существовавших парадигм и языков (в последнем случае — главным образом семейства Си).

В настоящее время развитие языков программирования идёт в направлении повышения безопасности и надёжности, создания новых форм модульной организации кода и интеграции с [[База данных|базами данных]].

== Спецификация языков ==

=== Стандартизация ===
Для многих широко распространённых языков программирования созданы международные стандарты. Специальные организации проводят регулярное обновление и публикацию [[Спецификация языков программирования|спецификаций]] и формальных определений соответствующего языка. В рамках таких комитетов продолжается разработка и модернизация языков программирования и решаются вопросы о расширении или поддержке уже существующих и новых языковых конструкций.

=== Алфавит ===
Современные языки программирования широко используют мультиязычные символы [[Юникод]]а ([[Delphi (язык программирования)|Delphi 2006]], [[C Sharp|C#]], [[Java]], [[Rust (язык программирования)|Rust]]) для идентификаторов и хранения исходного кода. Исторически, до начала 2000-х годов в языках применялась 7-и битная кодировка [[ASCII]], принятая стандартом в США.

Ранние языки, возникшие в эпоху [[Шестибитная кодировка|6-битных символов]], использовали более ограниченный набор. Например, алфавит Фортрана включает 49 символов (включая пробел): <nowiki>A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 = + - * / () . , $ ' :</nowiki> ''Управляющие'' символы ASCII используются ограниченно: допускаются только возврат каретки CR, перевод строки LF и горизонтальная табуляция HT (иногда также вертикальная табуляция VT и переход к следующей странице FF). Заметным исключением является язык [[АПЛ (язык программирования)|APL]], в котором используется очень много специальных символов.

{{details|Переносимый набор символов}}

Использование символов за пределами 7-битного [[ASCII]] (например, символов KOI8-R) зависит от реализации: иногда они разрешаются только в комментариях и символьных/строковых константах, а иногда и в идентификаторах.

В [[СССР]] и современной России существуют языки, где все ключевые слова пишутся русскими буквами, например [[встроенный язык программирования 1С:Предприятие]] и учебные языки программирования — [[Псевдокод (язык описания алгоритмов)|псевдокод,]] [[Учебный алгоритмический язык|школьный алгоритмический язык]] системы [[КуМир]] и [[Рапира (язык программирования)|язык РАПИРА]].

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

=== Грамматика ===
{{дополнить раздел|дата=2016-11-24}}
* [[Контекстно-свободная грамматика]]
* [[Контекстно-зависимая грамматика]]
* [[Регулярный язык]]
** [[регулярные выражения]]
* [[Грамматика с фразовой структурой]]
* [[LL-анализатор|LL(n)]]
* [[LALR(1)]]
* [[Yacc]]
* [[ANTLR]]
* [http://www.haskell.org/haskellwiki/Parsec Parsec]
* [[Абстрактное синтаксическое дерево|AST]]
* {{iw|Дерево разбора||en|parse tree}}
* {{iw|Абстрактный синтаксис первого порядка||en|first-order abstract syntax}}
* {{iw|Абстрактный синтаксис высшего порядка||en|higher-order abstract syntax}}

=== Семантика ===
{{main|Семантика (программирование)}}
Существует несколько подходов к определению семантики языков программирования. Основных три: [[операционная семантика|операционная]], [[аксиоматическая семантика|аксиоматическая]] и [[денотационная семантика|денотационная]].

* При описании семантики в рамках ''операционного'' подхода обычно исполнение конструкций языка программирования интерпретируется с помощью некоторой воображаемой (абстрактной) ЭВМ.
* ''Аксиоматическая'' семантика описывает последствия выполнения конструкций языка с помощью языка логики и задания пред- и постусловий.
* ''Денотационная'' семантика оперирует понятиями, типичными для математики — множества, соответствия, а также суждения, утверждения и др.

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

Конкретный язык программирования в подавляющем большинстве случаев имеет более одного языка-предка. Многие языки создаются как сочетание элементов различных языков. В одних случаях такое сочетание проходит математический анализ на предмет непротиворечивости (см., например, [[Standard ML#Определение|Определение {{nobr|Standard ML}}]]), в других — язык формируется исходя из практических потребностей, для решения актуальных проблем с целью получения коммерческого успеха, но при этом без соблюдения математической строгости и со включением в язык взаимоисключающих идей (как в случае [[C++]]<ref name=evolving>{{cite web|url = http://stroustrup.com/hopl-almost-final.pdf|title = Evolving a language in and for the real world: C++ 1991-2006|first = Bjarne|last = Stroustrup|access-date = 2017-01-16|archive-date = 2007-11-20|archive-url = https://web.archive.org/web/20071120015600/http://www.research.att.com/~bs/hopl-almost-final.pdf|url-status = live}}</ref><ref>{{публикация|книга
 | автор               = Т. Пратт, М. Зелковиц
 | заглавие            = Языки программирования. Разработка и реализация
 | место               = Санкт-Петербург
 | издательство        = Питер
 | год                 = 2002
 | издание             = 4
 | страницы            = 203
 | страниц             = 688
 | тираж               = 4000
 | isbn                = 5-318-00189-0
}}</ref><ref name=design>{{публикация|книга
 | автор               = Страуструп Б.
 | заглавие            = [[Дизайн и эволюция C++]]
 | ссылка              =
 | место               = Санкт-Петербург
 | издательство        = Питер
 | год                 = 2006
 | страницы            = 74—76
 | страниц             = 448
 | тираж               = 2000
 | isbn                = 5-469-01217-4
}}</ref>{{sfn|Сейбел - Кодеры за работой|2011|loc=Глава 12. Кен Томпсон|с=414}}<ref>{{Cite web|url=http://citforum.ru/programming/prg96/76.shtml|title=Язык программирования Си++: этапы эволюции и современное состояние|author=Зуев Е.А., Кротов А.Н., Сухомлин В.А.|website=|date=1996-10-04|publisher=|accessdate=2017-01-16|archive-date=2017-01-18|archive-url=https://web.archive.org/web/20170118032639/http://citforum.ru/programming/prg96/76.shtml|url-status=live}}</ref>).

=== Языки низкого и высокого уровня ===
Формально язык программирования не имеет такого критерия как «уровень». Условно этот термин обычно означает одно из двух:
* «приближенность» языка программирования к естественному человеческому языку и образу мысли,
* «удалённость» семантики языка программирования от [[машинный код|машинного кода]] целевой [[Архитектура процессора|архитектуры процессора]] — то есть наименьший масштаб преобразований, которые должен претерпеть код программы перед тем, как он сможет исполняться.
Эта двойственность появилась в [[1950-е годы]], при создании языков [[Планкалкюль]] и [[Фортран]]. При их разработке ставились прямые намерения обеспечить более краткую запись часто встречающихся конструкций (например, арифметических выражений), чем требовали процессоры того времени. В этих языках вводился новый слой абстракции и предполагались преобразования программ в [[машинный язык]], поэтому их назвали языками «высокого уровня», то есть надстройкой, надслоением над языком машины.
Однако вскоре стало ясно, что эти определения вовсе не обязательно идут бок о бок. Так, история знает случаи, когда язык, традиционно считающийся «высокоуровневым», реализовывался аппаратно (см. [[Лисп-машина]], {{iw|Java Optimized Processor}}), или когда язык, являющийся «низкоуровневым» на одной платформе, компилировался как «высокоуровневый» на другой (таким образом программы на [[CISC]]-ассемблере [[VAX]] использовались на [[RISC]]-машинах [[DEC Alpha]] — см. {{iw|VAX Macro}}). Тем не менее, до сих пор распространено заблуждение, что эти две трактовки являются не более, чем «двумя сторонами одной медали», и первое будто бы неизбежно означает второе.

По степени «высокоуровневости» языки принято делить на пять поколений.

К '''{{iw|Язык программирования первого поколения|первому поколению|en|first-generation programming language}}''' относят, в первую очередь, [[машинный язык|машинные языки]] (или, на общеупотребимом жаргоне — машинные коды), то есть языки, реализованные непосредственно на аппаратном уровне.

Появившиеся вскоре после них «[[Язык ассемблера|языки ассемблера]]» относят ко '''{{iw|Язык программирования второго поколения|второму поколению|en|second-generation programming language}}'''. В простейшем случае они реализуют мнемонику над машинным языком для записи команд и их параметров (в частности, адресов в памяти), но многие языки ассемблера включают и весьма развитый [[макрокоманда|макроязык]]; кроме того, даже в простейшем случае [[обратная разработка]] машинного кода не позволяет однозначно восстановить программу на ассемблере — например, невозможно восстановить имена переменных; могут быть нераспознаны [[недокументированные возможности|недокументированные функции]]. Тем не менее, оба первых поколения общепринято относить к [[Низкоуровневый язык программирования|языкам низкого уровня]].

К [[1970-е годы|1970-м годам]] сложность программ выросла настолько, что превысила способность программистов управляться с ними, и это привело к огромным убыткам и застою в развитии информационных технологий{{sfn|Paulson, «ML for the Working Programmer»|1996|с=213}}. Ответом на эту проблему стало появление массы языков [[Язык программирования высокого уровня|высокого уровня]], предлагающих самые разные способы управления сложностью (подробнее см. [[#Парадигма программирования|парадигма программирования]] и [[#Языки для программирования в мелком и крупном масштабе|языки для программирования в мелком и крупном масштабе]]). Программы на языках «высокого уровня» гораздо легче модифицируются и совсем легко переносятся с компьютера на компьютер.

На практике, [[мейнстрим|наибольшее распространение]] получили языки ''третьего'' поколения, которые лишь ''претендуют'' на звание «высокоуровневых», но реально предоставляют лишь те «высокоуровневые» конструкции, что находят однозначное соответствие инструкциям в [[Архитектура фон Неймана|машине фон Неймана]]{{sfn|Paulson, «ML for the Working Programmer»|1996|с=1}}.

Более «высокоуровневыми» принято считать языки ''четвёртого'' и ''пятого'' поколения.

К '''{{iw|Язык программирования четвёртого поколения|четвёртому поколению|en|fourth-generation programming language}}''' относят языки запросов, языки опций и параметров, генераторы приложений, комбинированные пакеты баз данных{{sfn|Брукс|1995}}. Наиболее значимой подгруппой в четвёртом поколении принято считать функциональные{{переход|Парадигма программирования|text}} языки, большая часть из которых является языками высшего порядка{{переход|Языки первого и высшего порядка|text}}.

Иногда выделяется категория языков '''{{iw|Язык программирования пятого поколения|пятого поколения|en|fifth-generation programming language}}''', но она не является общепринятой — чаще используется термин «язык сверхвысокого уровня» ({{lang-en|very high level language}}). Это языки, реализация которых включает существенную алгоритмическую составляющую (то есть когда интерпретация небольшого исходного кода требует весьма сложных вычислений), поэтому порой также говорят, что языки пятого поколения — это фактически языки четвёртого поколения, дополненные базой знаний{{sfn|Mernik|2012|с=2—12}}. Чаще всего так называют [[Логическое программирование|логические языки]].

Язык [[Си (язык программирования)|Си]] является, вероятно, самым «низкоуровневым» в третьем поколении. Он изначально позиционировался как «высокоуровневый ассемблер» или «[[кроссплатформенность|кроссплатформенный]] ассемблер»; его также часто называют «языком среднего уровня» или даже «языком поколения 2,5». Он позволяет в значительной степени контролировать ''способ реализации'' алгоритма с учётом свойств, типичных для весьма большого числа аппаратных [[Архитектура процессора|архитектур]], но есть платформы, под которые реализации Си (даже с в нестандартном виде) отсутствуют по причине принципиальной невозможности или нецелесообразности их создания. Классификация потомка [[Си (язык программирования)|Си]], языка [[C++]], вызывает споры: его нередко называют «высокоуровневым», несмотря на то, что технически его семантика и система типов мало отличаются от тех, на которых основан [[Си (язык программирования)|Си]].

Со временем появились и другие языки среднего уровня, например, [[LLVM]], [[C--]]. Они преимущественно предназначены не для написания кода человеком, а для генерации промежуточного кода из более высокоуровневых языков с тем, чтобы обеспечить лучшее разделение компиляторов на [[фронтенд и бэкенд]].

В большинстве случаев языки высокого уровня порождают машинный код большего размера и исполняются медленнее. Однако некоторые языки высокого уровня для алгоритмически и структурно сложных программ могут давать заметное преимущество в эффективности, уступая низкоуровневым лишь на небольших и простых программах (подробнее см. [[#Эффективность языков|эффективность языков]]). Иначе говоря, потенциальная эффективность языка меняется с повышением его «уровня» нелинейно и вообще неоднозначно. При этом скорость разработки и трудоёмкость модификации, устойчивость и другие [[качество ПО|показатели качества]] в сложных системах оказываются гораздо важнее предельно возможной скорости исполнения — они обеспечивают различие между программой, что работает, и той, что нет{{sfn|Paulson, «ML for the Working Programmer»|1996|с=9}} — так что экономически более целесообразна эволюция аппаратного обеспечения (исполнение большего числа инструкций в единицу времени) и методов [[оптимизирующий компилятор|оптимизирующей компиляции]] (более того, последние десятилетия эволюция аппаратного обеспечения движется в направлении ''поддержки'' методов [[оптимизирующий компилятор|оптимизирующей компиляции]] для языков высокого уровня). К примеру, автоматическая [[сборка мусора]], присутствующая в большинстве высокоуровневых языков программирования, считается одним из важнейших улучшений, благотворно повлиявших на скорость разработки<ref>{{cite web|author=Rick Byers|url=https://courses.cs.washington.edu/courses/csep521/07wi/prj/rick.pdf|title=Garbage Collection Algorithms|publisher=courses.cs.washington.edu|accessdate=2016-12-28|lang=|description=Project for CSEP 521, Winter 2007|archive-date=2017-08-29|archive-url=https://web.archive.org/web/20170829112454/https://courses.cs.washington.edu/courses/csep521/07wi/prj/rick.pdf|url-status=live}}</ref>.

Поэтому в наши дни языки низкого уровня используются только в задачах [[системное программирование|системного программирования]]. Распространено ошибочное отождествление системного программирования с «низкоуровневым», основанное на мнении, что если необходим точный контроль за ресурсами, то язык сам не должен предполагать масштабных преобразований, иначе все усилия программиста окажутся напрасными. В действительности есть примеры, опровергающие это. Так, язык [[BitC]] является функциональным{{переход|Парадигма программирования|text}} языком высшего порядка{{переход|Языки первого и высшего порядка|text}}, то есть представителем ''четвёртого'' поколения («высокоуровневым»), но целиком и полностью ориентирован именно на [[системное программирование]] и уверенно конкурирует по скорости с [[Си (язык программирования)|Си]]. Языки ''третьего'' поколения [[C Sharp|C#]] и [[Limbo]] разрабатывались для использования одновременно как в системном программировании (с целью повышения отказоустойчивости [[операционная система|операционной системы]]), так и в прикладном — это обеспечивает единство платформы, что сокращает потери при трансляции.

=== Безопасные и небезопасные языки ===
Современные компьютеры представляют сложные данные реального мира в виде чисел в памяти компьютера. Это вводит в дисциплину программирования риск [[Человеческий фактор|человеческого фактора]], в том числе вероятность [[Безопасность доступа к памяти|ошибок доступа к памяти]]. Поэтому многие языки программирования сопровождаются средством контроля смысла операций над двоичными данными на основе сопровождающей их логической информации — [[система типов|системой типов]]. Однако существуют и [[бестиповый язык|бестиповые языки]], например, [[Forth]]. Большинство языков ассемблера являются [[бестиповый язык|бестиповыми]], но существуют и {{iw|Типизированный язык ассемблера|типизированные языки ассемблера|en|Typed assembly language}}, нацеленные на обеспечение минимальной безопасности низкоуровневых программ.

[[система типов|Системы типов]] языков делятся на [[динамическая типизация|динамические]] (потомки [[Lisp]], [[Smalltalk]], [[APL (язык программирования)|APL]]) и [[статическая типизация|статические]], а последние, в свою очередь, делятся на неполиморфные (потомки [[Алгол]]а и [[BCPL]]) и [[параметрический полиморфизм|полиморфные]] (потомки [[ML]]){{sfn|Appel - A Critique of Standard ML|1992|}}. Кроме того, они делятся на явные ({{lang-en|explicit}}) и неявные ({{lang-en|implicit}}) — другими словами, требующие [[Явное назначение типов|явной декларации]] типов для объектов в программе или статически [[выведение типов|выводящие]] их самостоятельно.

Системы типов бывают [[сильная и слабая типизация|сильные и слабые]]. Сильная система типов назначает [[тип данных|тип]] для всякого выражения раз и навсегда (когда бы конкретно это ни происходило — в [[динамическая типизация|динамике]] или в [[статическая типизация|статике]]), а слабая позволяет впоследствии переназначать типы. Сильная типизация порой ошибочно отождествляется со статической.

В общем и целом, язык называется [[типобезопасность|безопасным]], если программы на нём, которые могут быть приняты компилятором как правильно построенные, в динамике никогда не выйдут за рамки допустимого поведения{{sfn|Harper — Practical Foundations for Programming Languages|2012|loc=Chapter 4. Statics|с=35}}. Это не значит, что такие программы не содержат ошибок вообще. Термин «хорошее поведение программы» ({{lang-en|well-behavior}}) означает, что даже если программа содержит некий [[ошибка (программирование)|баг]] (в частности, [[Логическая ошибка (программирование)|логическую ошибку]]), то она тем не менее ''не способна'' нарушить целостность данных и [[Крах программного обеспечения|обрушиться]] ({{lang-en|crash}}). Хотя термины неформальны, [[безопасность языка|безопасность]] некоторых языков (например, {{nobr|[[Standard ML]]}}) [[доказательство (математика)|математически доказуема]]{{sfn|Appel - A Critique of Standard ML|1992|}}. Безопасность других (например, [[Ада (язык программирования)|Ada]]) была обеспечена [[ad hoc]]-образом, без обеспечения концептуальной целостности, что может обернуться катастрофами, если положиться на них в ответственных задачах (см. [[#Концептуальная целостность языков|концептуальная целостность языков]]). Неформальная терминология была популяризована [[Милнер, Робин|Робином Милнером]], одним из авторов теории [[формальная верификация|формальной верификации]] и собственно языка {{nobr|[[Standard ML]]}}.

Степень контроля ошибок и реакция языка на них могут различаться. Простейшие системы типов запрещают, к примеру, вычитать [[Строковый тип|строку]] из [[Целый тип|целого числа]]. Однако целыми числами могут представляться и [[миллиметр]]ы, и [[дюйм]]ы, но было бы [[Логическая ошибка (программирование)|логической ошибкой]] вычитать дюймы из миллиметров. Развитые системы типов позволяют (а наиболее развитые — принуждают) внедрять в программу такую логическую информацию. Для ЭВМ она является избыточной и полностью удаляется при порождении машинного кода тем или иным образом{{переход|#Компилируемые и интерпретируемые языки|text}}. В частности, {{nobr|[[Standard ML]]}} не допускает над данными никаких операций, кроме тех, что разрешены явно и формализованы; однако программы на нём всё же могут завершаться порождением [[обработка исключений|необработанного исключения]] (например, при попытке [[деление на ноль|деления на ноль]]). Его потомок, [[Standard ML#MLPolyR|MLPolyR]] гарантирует также и отсутствие необработанных исключений. Такие языки называются «[[типобезопасность|типобезопасными]]». [[Java]] и [[C Sharp|C#]] менее строги и контролируют лишь [[утечка памяти|утечки памяти]], поэтому в их контексте чаще используют более узкий термин «''безопасность типов в отношении доступа к памяти''» ({{lang-en|memory type safety}}) или (чаще) просто «[[безопасность доступа к памяти]]». [[сильная и слабая типизация|Сильно]] [[динамическая типизация|динамически]] типизируемые языки отслеживают поведение программ в динамике (что влечёт снижение быстродействия) и реагируют на ошибки порождением исключения. Все эти языки ориентированы на ''практичность'', предоставляя оптимальный компромисс между пресечением серьёзных сбоев и высокой скоростью разработки программ.

Существуют языки, предназначенные для написания программ, которые ''верны по построению'', то есть обеспечивают гарантию того, что исполнимая программа по структуре и поведению будет ''тождественна'' её спецификации (см. {{iw|параметричность||en|parametricity}}, [[зависимый тип]]). Как следствие, программы на таких языках часто называют «исполнимыми спецификациями» (см. [[Соответствие Карри — Говарда]]). Трудоёмкость разработки на таких языках возрастает на порядки, к тому же они требуют очень высокой квалификации разработчика — поэтому их применяют только в [[формальная верификация|формальной верификации]]. Примерами таких языков служат [[Agda]], [[Coq]].

Языки [[Си (язык программирования)|Си]] и его потомок [[C++]] являются небезопасными{{sfn|Mitchel|2004|loc=6.2.1 Type Safety|с=132—133}}. В программах на них обширно встречаются ситуации [[сильная и слабая типизация|ослабления]] типизации ([[приведение типов]]) и прямого её нарушения ([[каламбур типизации]]), так что [[Безопасность доступа к памяти|ошибки доступа к памяти]] являются в них статистической нормой (но [[Крах программного обеспечения|крах]] программы наступает далеко не сразу, что затрудняет поиск места ошибки в коде). Самые мощные системы [[Статический анализ кода|статического анализа]] для них (такие, как [[PVS-Studio]]<ref>{{Cite web |url=http://www.viva64.com/en/b/0241/ |title=Comparison of static code analyzers: CppCat, Cppcheck, PVS-Studio and Visual Studio |access-date=2016-10-25 |archive-date=2016-10-26 |archive-url=https://web.archive.org/web/20161026163311/http://www.viva64.com/en/b/0241/ |url-status=live }}</ref><ref>{{Cite web |url=http://www.viva64.com/en/a/0052/#ID0EBKAE |title=Comparing PVS-Studio with other code analyzers |access-date=2016-10-25 |archive-date=2016-10-26 |archive-url=https://web.archive.org/web/20161026075717/http://www.viva64.com/en/a/0052/#ID0EBKAE |url-status=live }}</ref>) способны обнаруживать не более {{nobr|70 — 80 %}} ошибок, но их использование обходится очень дорого, как в финансовом смысле, так и с точки зрения трудоёмкости и наукоёмкости. Достоверно же гарантировать безотказность программ на этих языках невозможно, не прибегая к [[формальная верификация|формальной верификации]], что не только ещё дороже, но и требует специальных знаний. У Си есть и безопасные потомки, такие как [[Cyclone (язык программирования)|Cyclone]].

Язык [[Forth]] не претендует на звание «безопасного», но тем не менее на практике существование программ, способных повредить данные, почти исключено, так как содержащая потенциально опасную ошибку программа аварийно завершается на первом же тестовом запуске, принуждая к коррекции исходного кода. В сообществе [[Erlang]] принят подход «let it crash» ({{tr-en|дай ей обрушиться}}), также нацеленный на раннее выявление ошибок.

=== Компилируемые, интерпретируемые и встраиваемые языки {{якорь|Компилируемые и интерпретируемые языки}} ===
Можно выделить три принципиально разных способа реализации языков программирования: [[Компилируемый язык программирования|компиляция]], [[Интерпретируемый язык программирования|интерпретация]] и [[Предметно-ориентированный язык#Встраиваемый язык|встраивание]]. Распространено заблуждение, согласно которому способ реализации является ''присущим'' конкретному языку свойством. В действительности, это деление до определённой степени условно. В ряде случаев язык имеет ''формальную семантику, ориентированную на интерпретацию'', но все или почти все его действительные реализации являются компиляторами, порой весьма эффективно [[оптимизирующий компилятор|оптимизирующими]] (примерами могут служить языки семейства [[ML]], такие как [[Standard ML]], [[Haskell]]). Есть языки, размывающие границы между интерпретацией и компиляцией — например, [[Forth]].

Компиляция означает, что [[исходный код]] программы сначала преобразуется в целевой ([[машинный код|машинный]]) код специальной программой, называемой [[компилятор]]ом — в результате получается [[исполнимый модуль]], который уже может быть запущен на исполнение как отдельная программа. Интерпретация же означает, что [[исходный код]] выполняется непосредственно, команда за командой (иногда — с минимальной подготовкой, буквально после разбора исходного кода в [[Абстрактное синтаксическое дерево|AST]]),— так что программа просто не может быть запущена без наличия [[интерпретатор]]а. [[Предметно-ориентированный язык#Встраиваемый язык|Встраивание языка]] можно философски рассматривать как «реализацию без [[транслятор|трансляции]]» — в том смысле, что такой язык является синтаксическим и семантическим подмножеством некого другого языка, без которого он не существует. Говоря же более точно, [[Предметно-ориентированный язык#Встраиваемый язык|встраиваемые языки]] добавляют к сказанному ещё четыре способа реализации.

Естественный для языка способ реализации определяется ''временем связывания'' программных элементов с их характеристиками. В частности, в языках со [[Статическая типизация|статической типизацией]] переменные и другие объекты программы связываются с типом данных на этапе компиляции, а в случае [[Динамическая типизация|типизации динамической]] — на этапе выполнения, как правило — в произвольной точке программы. Некоторые свойства элементов языка, такие как значение арифметических операторов или управляющих ключевых слов, могут быть связаны уже на этапе определения языка. В других языках возможно их переназначение (см. {{iw|связывание имён||en|Name binding}}). Раннее связывание обычно означает бо́льшую эффективность программы, в то время как позднее — большую гибкость, ценой которого является меньшая скорость и/или усложнение соответствующего этапа{{Sfn|Пратт|1979|loc=2.7. Связывание и время связывания|страницы=46—51}}. Но даже из, казалось бы, очевидных случаев есть исключения — например, [[Параметрический полиморфизм#Интенсиональный полиморфизм|интенсиональный полиморфизм]] откладывает обработку статической типизации до этапа выполнения, но не замедляя, а повышая общее быстродействие (по крайней мере, в теории).

Для любого традиционно компилируемого языка (такого как [[Паскаль (язык программирования)|Паскаль]]) можно написать интерпретатор. Но многие ''интерпретируемые языки'' предоставляют некоторые дополнительные возможности, такие как динамическая [[порождающее программирование|генерация кода]] (см. {{iw|eval}}), так что их компиляция должна быть динамической (см. [[JIT-компиляция|динамическая компиляция]]). Таким образом, составной термин «язык + способ его реализации» в ряде случаев оказывается уместен. Кроме того, большинство современных «чистых» интерпретаторов не исполняют конструкции языка непосредственно, а компилируют их в некоторое высокоуровневое промежуточное представление (например, с разыменованием переменных и раскрытием [[макрокоманда|макрокоманд]]). Большинство традиционно интерпретируемых или компилируемых языков могут реализовываться как [[Предметно-ориентированный язык#Встраиваемый язык|встраиваемые]], хотя [[метаязык]]ов, которые были бы способны охватить другие языки как своё подмножество, не так много (наиболее ярким представителем является [[Lisp]]).

Как правило, скомпилированные программы выполняются быстрее и не требуют для выполнения дополнительных программ, так как уже переведены на машинный язык. Вместе с тем, при каждом изменении текста программы требуется её перекомпиляция, что замедляет процесс разработки. Кроме того, скомпилированная программа может выполняться только на том же типе компьютеров и, как правило, под той же операционной системой, на которую был рассчитан компилятор. Чтобы создать исполняемый файл для машины другого типа, требуется новая компиляция. Интерпретируемые языки позволяют запускать программы сразу же после изменения, причём на разных типах машин и операционных систем без дополнительных усилий, а [[гомоиконичность|гомоикони́чные]] — и вовсе динамически перемещать программу между разными машинами без прерывания её работы (наиболее общий случай [[сериализация|сериализации]]), позволяя разрабатывать {{iw|Непрерывная доступность|системы непрерывной доступности|en|Continuous availability}} (''см. тж.'' [[высокая доступность|системы высокой доступности]]). [[кроссплатформенность|Портируемость]] интерпретируемой программы определяется только наличием реализаций интерпретаторов под те или иные аппаратные платформы. Ценой всего этого становятся заметные потери быстродействия; кроме того, если программа содержит фатальную ошибку, то об этом не будет известно, пока интерпретатор не дойдёт до её места в коде (в отличие от статически [[типобезопасность|типобезопасных]] языков{{переход|#Безопасные и небезопасные языки|text}}).

Реализация некоторых языков, например, [[Java]] и [[C Sharp|C#]], занимают промежуточную ступень между компиляцией и интерпретацией. А именно, программа компилируется не в машинный язык, а в [[кроссплатформенность|машинно-независимый]] код низкого уровня, [[байт-код]]. Далее байт-код выполняется [[виртуальная машина|виртуальной машиной]]. Для выполнения байт-кода обычно используется интерпретация, хотя отдельные его части для ускорения работы программы могут быть транслированы в машинный код непосредственно во время выполнения программы по технологии компиляции «на лету» (Just-in-time compilation, [[JIT]]). Для Java байт-код исполняется виртуальной машиной Java (Java Virtual Machine, [[JVM]]), для C# — [[Common Language Runtime]]. Подобный подход в некотором смысле позволяет использовать плюсы как интерпретаторов, так и компиляторов.

=== Языки первого и высшего порядка ===

==== Начальные сведения ====
[[Математическая логика]] классифицируется по [[Теория порядков|порядку]] — см. [[логика первого порядка]] и [[логика высшего порядка]]. Эта терминология естественным образом наследуется [[информатика|информатикой]], образуя семантики, соответственно, первого и высшего порядка{{sfn|Reynolds, «Theories of programming languages»|1998|loc=12.4 Deriving a First-Order Semantics}}. Языки первого порядка (например, потомки [[Алгол]]а, такие как [[Basic]] или классический [[Pascal]] Вирта) позволяют определять только зависимости первого порядка между величинами. Например, значение <code>square x</code> зависит от значения <code>x</code>. Такие зависимости называются [[Функция (программирование)|функциями]]. Языки высшего порядка позволяют определять зависимости между зависимостями. Например, значение <code>[[Map (программирование)|map]] f x</code> зависит от значений <code>f</code> и <code>x</code>, где значение <code>f</code> само выражает [[абстракция (информатика)|абстрактную]] зависимость (другими словами, [[параметр (программирование)|параметр]] <code>f</code> варьируется над множеством функций определённой [[сигнатура функции|сигнатуры]]). Такие зависимости называются [[функция высшего порядка|функциями высшего порядка]]. При этом в большинстве случаев говорят, что такой язык рассматривает зависимости ([[функция (информатика)|функции]]) как [[объект первого класса|объекты первого класса]], иначе говоря, допускает [[функции первого класса]] (некоторые языки, например [[Си (язык программирования)|Си]], не поддерживают первоклассные функции, но предоставляют ограниченные возможности строить функции высшего порядка). Эти термины ввёл {{iw|Стрэчи, Кристофер|Кристофер Стрэчи|en|Christopher Strachey}} в {{iw|Фундаментальные понятия в языках программирования|публикации 1967 года|en|Fundamental Concepts in Programming Languages}}. К языкам высшего порядка относятся почти все [[функциональное программирование|функциональные языки]] (исключения очень редки; примером функционального языка первого порядка долгое время являлся {{iw|SISAL}}, но в 2018 году в него была добавлена поддержка первоклассных функций). С развитием [[система типов|систем типов]] различение [[Теория порядков|порядков]] распространилось и на [[тип данных|типы]] (см. [[конструктор типов]]).

==== Выразительность ====
Языки первого порядка позволяют воплощать в виде кода [[алгоритм]]ы, но не [[проектирование программного обеспечения|архитектуру программ]]. По мнению {{iw|Стрэчи, Кристофер|Стрэчи|en|Christopher Strachey}}, это ограничение унаследовано языком [[Алгол]] (а от него другими языками) из классической математики, где используются только константные операции и функции, однозначно распознаваемые вне контекста, и отсутствует систематичная нотация для произвольной работы с функциями (в качестве такой нотации в 1930-х годах было построено [[лямбда-исчисление]], которое позже легло в основу языков высшего порядка){{sfn|Strachey — Fundamental Concepts|1967|loc=3.5.1. First and second class objects|с=32—34}}. ''Схемы взаимодействия'' компонентов ([[процедура (программирование)|процедур]], [[функция (программирование)|функций]], [[объект (программирование)|объектов]], [[процесс (информатика)|процессов]] и др.) для программ на языках первого порядка могут существовать лишь на условном уровне, вне самих программ. Со временем были обнаружены многократно повторяющиеся ''однотипные'' схемы такого рода, в результате чего вокруг них выстроилась самостоятельная методология — [[шаблоны проектирования]]. Языки высшего порядка позволяют воплощать такие схемы в виде исполнимого кода, пригодного для [[повторное использование кода|многократного использования]] (функций, предназначенных для [[комбинатор|преобразования и композиции]] других функций — см., например, [[Standard ML#Конверторы и сканеры|конверторы и сканеры в SML]]){{sfn|SICP}}{{sfn|Harper — Practical Foundations for Programming Languages|2012|с=67|loc=8.2 Higher-Order Functions}}. В результате, решения, которые на языках первого порядка могут быть представлены фрагментами программ (порой довольно сложными и громоздкими), на языках высшего порядка могут сокращаться до одной команды или вообще использования элемента семантики самого языка, не имеющего синтаксического выражения. Например, шаблон «[[Команда (шаблон проектирования)|Команда]]», часто применяемый в языках первого порядка, эквивалентен непосредственно самому понятию [[функции первого класса]]. То же распространяется и на более высокие слои языков — типизацию (см. [[полиморфизм в высших родах|полиморфизм в высших рода́х]]) и типизацию типизации (см. [[полиморфизм родов|полиморфизм родо́в]]).

{{details|Шаблоны проектирования#Минусы}}

Сказанное преимущественно относится к языкам, семантика которых основана на [[лямбда-исчисление|лямбда-исчислении]] (потомки [[Lisp]], [[ML]]). Однако некоторые языки иной природы также предоставляют возможность {{iw|Программирование высшего порядка|программирования высшего порядка|en|Higher-order programming}}. Примерами служат [[стековый язык|стековые языки]] ([[Forth]]) и определённая разновидность [[Объектно-ориентированное программирование|объектно-ориентированных]] языков ([[Smalltalk]], [[CLOS]], см. {{iw|сообщение высшего порядка||en|Higher order message}}).

==== Изучение ====
Введя терминологию «сущностей первого и второго класса», {{iw|Стрэчи, Кристофер|Стрэчи|en|Christopher Strachey}} тут же акцентировал внимание на том, что из личного опыта и обсуждений со множеством людей он убедился, что невероятно тяжело перестать думать о функциях как об объектах второго класса{{sfn|Strachey — Fundamental Concepts|1967|loc=3.5.1. First and second class objects|с=32—34}}. То есть порядок языка имеет ярко выраженное психологическое влияние (см. [[гипотеза Сепира — Уорфа]]). Владение языками более высокого уровня поможет программисту думать в терминах более высокоуровневых абстракций{{sfn|Пратт, Зелковиц|2002|loc=1.1 Зачем изучать языки программирования|с=17—18}}.

Низкоуровневые же языки могут навязывать обратное, в связи с чем широко известно следующее высказывание:
{{начало цитаты}}Практически невозможно обучить хорошему программированию студентов, имевших опыт работы с Бейсиком: как потенциальные программисты они ментально исковерканы без надежды на восстановление.{{oq|en|It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration}}{{конец цитаты|источник=[[Дейкстра, Эдсгер Вибе|Эдсгер Дейкстра]]}}

Это значит, что само по себе использование языка высшего порядка не означает автоматически изменение [[проектирование программного обеспечения|архитектуры]] и повышение коэффициента [[повторное использование кода|повторного использования]] (см. [[серебряной пули нет]]) — определяющим фактором является ''умение'' конкретного разработчика применять соответствующие [[Идиома (программирование)|идиомы]]<ref>{{Книга|автор=Bruce A. Tate |часть=Foreword |заглавие=Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages |ссылка=https://archive.org/details/sevenlanguagesin00tate |ответственный= |издание= |место= |издательство=Pragmatic Bookshelf |год=2010 |страницы=[https://archive.org/details/sevenlanguagesin00tate/page/14 14]—16 |страниц= |isbn=978-1934356593 |ref= }}</ref>.

Понимание возможностей и ограничений высокоуровневых конструкций, базовых принципов их реализации не только дают программисту возможность наиболее эффективно использовать изученный им язык, но и позволят создавать и использовать аналогичные механизмы в случае разработки на языке, где они не реализованы{{sfn|Пратт, Зелковиц|2002|loc=1.1 Зачем изучать языки программирования|с=17—18}}.

Разработчику, владеющему бо́льшим спектром языков программирования, будет проще выбрать среди них инструмент, наиболее подходящий для решения стоящей перед ним задачи, изучить, в случае необходимости, новый язык или реализовать [[предметно-ориентированный язык]], к которым, к примеру, можно отнести [[интерфейс командной строки]] достаточно сложной программы{{sfn|Пратт, Зелковиц|2002|loc=1.1 Зачем изучать языки программирования|с=18}}.

=== Парадигма программирования ===
{{Парадигмы программирования}}
{{main|Парадигма программирования}}

Язык может ''технически допускать'' или ''не допускать'', а также в той или иной степени ''поощрять'' или ''не поощрять'' реализацию определённых [[идиома (программирование)|идиом]] и разработку в некоторой [[парадигма программирования|парадигме программирования]] (если таких парадигм несколько, язык называют [[мультипарадигменный язык программирования|мультипарадигменным]]).

Технически языки делятся, например, на допускающие [[побочный эффект (программирование)|побочные эффекты]] и не допускающие их. Во втором случае язык называют ''[[ссылочная прозрачность|ссылочно-прозрачным]]'' и относят к «[[Функциональное программирование|чисто функциональной парадигме]]». Также в качестве парадигмы иногда рассматриваются определённые свойства [[система типов|системы типов]] и [[стратегия вычисления|стратегии вычисления]] языка (например, для [[параметрический полиморфизм|параметрически полиморфных]] систем типов нередко говорят о реализации парадигмы [[обобщённое программирование|обобщённого программирования]]) или наличие определённых семантических свойств (например, свойство [[Гомоиконичность|гомоикони́чности]], открывающее целый спектр разновидностей [[метапрограммирование|метапрограммирования]]).

Существует масса «языков, наследованных от математики»{{переход|#Математически обоснованные языки программирования|text}}, многие из которых формируют уникальные парадигмы. Яркими представителями являются [[Lisp]], впервые воплотивший [[лямбда-исчисление]] и положивший таким образом начало [[Функциональное программирование|функциональной парадигме]]; [[Smalltalk]], впервые воплотивший [[объектно-ориентированное программирование|объектно-ориентированную парадигму]] (появившаяся за много лет до него [[Симула]] поддерживала понятие [[класс (программирование)|класса]], но воплощала [[структурное программирование|структурную парадигму]]) и [[стековый язык]] [[Forth]], воплощающий [[Конкатенативный язык программирования|конкатенативную парадигму]].

[[Низкоуровневый язык программирования|Низкоуровневые языки]] ориентированы на специфику конкретного аппаратного обеспечения, и обычно не соотносятся с какой-либо парадигмой, кроме императивной (см. далее), хотя конкретный разработчик на них, разумеется, может идеологически следовать определённым тенденциям. Однако, некоторые архитектуры могут реализовывать нетипичные возможности, существенно влияющие на подход к декомпозиции задачи в низкоуровневом программировании, например, [[параллелизм на уровне команд]].

С точки зрения общей философии программирования языки делятся на [[императивное программирование|императивные]] и [[декларативное программирование|декларативные]].

[[императивное программирование|Императивные]] языки подразумевают программирование посредством ''пошагового инструктирования'' машины, детального указания уже придуманного программистом ''способа реализации'' технического задания (термин «императив» означает «приказной порядок»).

[[декларативное программирование|Декларативные]] языки подразумевают программирование посредством описания требуемого результата в терминах предметной области и возложение работы по получению способа реализации полностью или почти полностью на автоматику (компилятор, библиотеку, макроподсистему и др.) с применением методов {{iw|Преобразование программ|автоматических преобразований программ|en|program transofrmation}}. На таких языках в большинстве случаев достаточно просто перекомпилировать программу под определенную [[Архитектура процессора|архитектуру]] и [[операционная система|операционную систему]], а адаптации исходного кода не требуется (термин «декларатив» означает «описание»).

Чем точнее язык позволяет контролировать, ''как'' требуемая функциональность будет исполняться на данном процессоре с учётом особенностей его архитектуры, тем легче обеспечить достоверно высокое быстродействие и компактность программ. Оборотной стороной медали является снижение [[кроссплатформенность|портируемости]]: для переноса программы на другую аппаратную платформу её придётся перекодировать с нуля (а зачастую и перепроектировать — столь сильны могут быть различия между архитектурами процессоров), хотя в ряде случаев и удаётся обеспечить хорошую [[кроссплатформенность|портируемость]] кода между большим числом [[Архитектура процессора|процессорных архитектур]]. На декларативных языках в большинстве случаев достаточно просто перекомпилировать программу под определенную [[Архитектура процессора|архитектуру]] и [[операционная система|операционную систему]], а адаптации исходного кода не требуется. Порой для них применяется компиляция в языки более низкого уровня, в том числе в языки третьего поколения (в большинстве случаев это [[Си (язык программирования)|Си]], но иногда в роли целевых платформ выступают [[Java]], [[JavaScript]], [[Ada (язык программирования)|Ada]] и др.).

В соответствии с этим, нередко выделяются «'''''как''-языки'''» (языки, ориентированные на машину) и «'''''что''-языки'''» (языки, ориентированные на человека).

Распространено заблуждение относительно того, где находится верхний порог степени «высокоуровневости» или «декларативности»: глядя на программы на истинных ''что''-языках, опытные программисты на ''как''-языках зачастую не могут поверить, что перед ними действительно исполнимый код{{sfn|Hudak|1998|}}. Вследствие этого, однозначное отнесение языков '''''третьего''''' поколения к [[императивное программирование|императивным]] (''как''-языкам) зачастую вызывает споры и попытки продемонстрировать на них «декларативные» фрагменты кода. В действительности, как выше отмечено{{переход|#Языки низкого и высокого уровня|text}}, языки третьего поколения предоставляют лишь те «высокоуровневые» конструкции, что находят однозначное соответствие инструкциям в машине фон-Неймана{{sfn|Paulson, "ML for the Working Programmer"|1996|с=1}}. Существуют [[Архитектура процессора|процессорные архитектуры]], под которыми использование многих распространённых языков третьего поколения затруднено или невозможно, и в лучшем случае разрабатываются специализированные языки третьего поколения (как, например, [[Occam]] для [[транспьютер]]ов, или [[Шейдер|шейдерные языки]] для [[графический процессор|графических процессоров]]). Кроме того, зачастую упускается из виду, что [[объектно-ориентированное программирование]] в большинстве случаев представляет собой однозначно заданную цепочку обмена объектов сообщениями с целью изменения их [[состояние (информатика)|состояния]], что подпадает под определение «императив» (исключение может составлять [[агентное моделирование]]).

''Что''-языки могут использоваться не только для разработки прикладных программ под экзотичные системы, но даже для [[встраиваемый язык|моделирования внутри языка]] модели выполнения самих этих систем (см., например, Clash<ref>[http://clash-lang.org Clash] {{Wayback|url=http://clash-lang.org/ |date=20240104224223 }} — [[встраиваемый язык|встраиваемый DSL]] на [[Haskell]], предназначенный для моделирования процессоров и генерации описаний на Verilog/VHDL</ref>).

Как и с другими видами классификации, это деление языков не является строгим, а представляет своего рода градацию. К тому же развитые механизмы [[абстракция (информатика)|абстракции]] позволяют повышать степень «декларативности» языка с исходно императивной семантикой (подробнее см. [[встраиваемый язык]]). Многие декларативные языки также предусматривают императивные возможности. Более того, для множества задач полностью автоматическое порождение по-настоящему эффективной реализации [[алгоритмическая неразрешимость|алгоритмически неразрешимо]], так что на практике даже на ''что''-языках нередко используются определённые алгоритмические ухищрения, хотя и существуют методы получения эффективных реализаций из основанных на определении (реализаций «в лоб»), такие как изобретённая в [[СССР]] [[суперкомпиляция]]. Но в целом, [[Функциональное программирование|функциональные]] и [[логическое программирование|логические]] языки принято относить к декларативным, а [[процедурное программирование|процедурные]] и [[Объектно-ориентированное программирование|объектно-ориентированные]] — к императивным.

Уже при использовании языков второго поколения начала формироваться парадигма [[процедурное программирование|процедурного программирования]], требующая производить декомпозицию крупных [[подпрограмма|процедур]] в цепочку иерархически связанных более мелких. С появлением языков третьего поколения сформировалось сперва [[структурное программирование]] как прямое развитие [[процедурное программирование|процедурного]], а затем и [[модульное программирование|модульное]]. Все эти парадигмы реализованы во всех поколениях языков, начиная с третьего, они применяются и в императивных, и в декларативных языках (например, в [[Функциональное программирование|функциональных языках]] [[структурное программирование]] реализуется посредством лексической [[область видимости|области видимости]] — см. {{iw|Lexical scope}} и [[Замыкание (программирование)|замыкание]]).

Среди [[Функциональное программирование|функциональных языков]] выделяются «чисто функциональные» ({{lang-en|purely functional}}, соответствующие выше упомянутой технической категории [[ссылочная прозрачность|ссылочно-прозрачных]]); остальные называются «не чисто функциональными» ({{lang-en|impurely functional}}) или просто «языками высшего порядка»{{переход|Языки первого и высшего порядка|text}}.

Среди языков [[логическое программирование|логического программирования]], помимо традиционного, выделяется несколько особых форм, например, [[программирование ограничениями]].

Существует особый случай [[объектно-ориентированное программирование|объектно-ориентированной парадигмы]] — {{iw|Сообщение высшего порядка|ООП высшего порядка|en|Higher order message}} (см. также [[#Языки первого и высшего порядка]]). Распространено мнение, что во многих процедурных языках возможно [[идиома (программирование)|идиоматическое]] изображение ООП, однако это неверно, если говорить об ''ООП высшего порядка''.

Ещё по одной «шкале» можно выстроить языки по степени ''возможности избавиться'' от [[точка следования|точек следования]] для реализации [[Бесточечное программирование|бесточечного стиля]]. По одну сторону в этом случае окажутся, например, [[Си (язык программирования)|Си]] и [[Паскаль]], по другую — [[Joy (язык программирования)|Joy]], [[APL (язык программирования)|APL]]/[[J (язык программирования)|J]]/[[K (язык программирования)|K]]. Бесточечный стиль широко применяется в [[Haskell]], поддерживается в [[OCaml]].

=== Языки для программирования в мелком и крупном масштабе ===
{{main|:en:Programming in the large and programming in the small|l1=Программирование в крупном и мелком масштабе{{ref-en}}}}

Программы могут решать задачи {{iw|Программирование в крупном и мелком масштабе|различного масштаба|en|Programming in the large and programming in the small}}: одна программа строит график для заданной функции, а другая управляет документооборотом крупного предприятия. Различные языки программирования рассчитаны на разный исходный масштаб задачи и, что ещё более важно, по-разному справляются с ростом сложности программных систем. Ключевым качеством языка, от которого зависит, как меняется трудоёмкость разработки по мере наращивания системы, является [[абстракция (информатика)|абстракция]], то есть возможность ''отделять'' смысл (поведение) компонента системы от ''способа его реализации''{{sfn|Ахо, Ульман|1992|}}{{sfn|Joyner|1996|loc=2.2 Communication, abstraction and precision|с=4}}.

{{начало цитаты}}Рост сложности любой программной системы принципиально ограничен тем пределом, до которого ещё можно сохранять контроль над ней: если объём информации, требуемый для осмысления компонента этой системы, превышает «вместимость» мозга одного человека, то этот компонент не будет до конца понят. Станет чрезвычайно тяжело дорабатывать его или исправлять ошибки, и от каждой корректировки можно ждать введения новых ошибок из-за этого неполного знания.{{oq|en|There is a fundamental limit to complexity of any software system for it to be still manageable: if it requires more than «one brainfull» of information to understand a component of the system, then that component will ''not'' be understood fully. It will be extremely difficult to make enhancements or ﬁx bugs, and each ﬁx is likely to introduce further errors due to this incomplete knowledge.}}{{конец цитаты|источник=Martin Ward, «Language Oriented Programming»{{sfn|Ward|1994|}}}}

Такие показатели [[качество ПО|качества исходного кода]], как тестируемость и модифицируемость, очевидным образом определяются коэффициентом [[повторное использование кода|повторного использования]]. Это может означать как применение разных функций к одному и тому же компоненту, так и возможность применять одну и ту же функцию к разным компонентам. [[параметрический полиморфизм|Параметрически полиморфные]] (особенно [[выведение типов|выводящие]]) и [[динамическая типизация|динамические]] [[система типов|системы типов]] существенно повышают коэффициент [[повторное использование кода|повторного использования]]: например, функция, вычисляющая длину массива, будет применима к бесконечному множеству типов массивов{{sfn|Appel - A Critique of Standard ML|1992|}}{{sfn|Paulson, «ML for the Working Programmer»|1996|с=63—64}}. Если же язык требует в [[сигнатура функции|сигнатуре функции]] указывать конкретный способ реализации входных данных, то этот коэффициент резко страдает. Например, [[Pascal]] критиковался за необходимость всегда указывать конкретный размер массива{{sfn|Kernigan about Pascal|1981|}}, а [[C++]] — за необходимость различать <code>.</code> и <code>-></code> при обращении к компонентам {{iw|Составной тип данных|составных данных|en|Composite data type}}{{sfn|Joyner|1996|loc=3.17 ‘.’ and ‘->’|с=26}}. Языки высшего порядка{{переход|#Языки первого и высшего порядка|text}} позволяют выделять ''схемы взаимодействия'' функций в многократно вызываемый блок кода ([[функция высшего порядка|функцию высшего порядка]]){{sfn|SICP|}}{{sfn|Paulson, «ML for the Working Programmer»|1996|с=177—178}}, а наибольших значений повторное использование достигает при переходе к языку более высокого уровня — при необходимости [[языково-ориентированное программирование|специально разрабатываемого для данной задачи]] — в этом случае повторно используется язык, а не одна функция{{sfn|Ward|1994|}}, а сама разработка языка может вестись с интенсивным повторным использованием компонентов компилятора{{sfn|Hudak|1998|}}.

С развитием языков появились особые (присущие исключительно программированию, не требовавшиеся ранее в математике) категории компонентов и зависимостей: [[монада (программирование)|монады]], [[Класс типов|классы типов]], [[Параметрический полиморфизм#Полиморфизм управляющих конструкций|полиморфные ветвления]], [[Аспектно-ориентированное программирование|аспекты]] и др. Их использование позволяет выражать бо́льшую функциональность в том же объёме кода, тем самым переводя {{iw|Программирование в крупном и мелком масштабе|программирование-по-крупному|en|Programming in the large and programming in the small}} в более мелкий масштаб.

Другие фундаментальные проблемы, связанные со сложностью крупных систем, лежат вне самих программ: это взаимодействие разрабатывающих её программистов между собой, [[Документация на программное обеспечение|документирование]] и т. д. Помимо обеспечения [[абстракция (информатика)|абстракции]], не последнюю роль в этом играет концептуальная целостность{{переход|#Концептуальная целостность языков|text}} выбранного языка программирования{{sfn|Брукс|1975, 1995|}}{{sfn|Ward|1994|}}.

Кроме свойств семантики языка, повторное использование может обеспечиваться посредством [[модульное программирование|модульной структуры]] программной системы или комплекса. Более того, сколь бы гибким ни был язык, работа с огромными объёмами кодов, особенно множеством людей, требует их декомпозиции на модули тем или иным образом. Модульная структура подразумевает не просто разбиение монолитного исходного кода программы на множество текстовых файлов, а обеспечение абстракции в более крупном масштабе, то есть определение [[интерфейс (программирование)|интерфейса]] для всякого логически завершённого фрагмента и [[сокрытие (программирование)|сокрытие]] деталей его реализации. В зависимости от применённых в языке правил определения [[область видимости|области видимости]] язык может допускать или не допускать автоматическое определение зависимостей. Если согласно правилам ''возможен'' конфликт имён, то автоопределение зависимостей невозможно, и тогда в заголовке модуля требуется явно перечислять имена модулей, компоненты которых в нём используются.

Некоторые языки (например, [[Basic]] или классический [[Pascal]] [[Вирт, Никлаус|Вирта]]) ориентированы исключительно на разработку мелких, структурно простых программ. Они не обеспечивают ни развитой системы модулей, ни гибкости конкретных фрагментов. Язык Си создавался как «высокоуровневый ассемблер», что само по себе не предполагает разработку систем выше некоторого порога сложности, поэтому поддержка крупномасштабного программирования в него заложена также не была. Некоторые языки высокого и сверхвысокого уровня ([[Erlang]], [[Smalltalk]], [[Prolog]]) предоставляют в качестве базовых примитивных элементов концепции, которые в других языках представляются конструктивно и алгоритмически сложными ([[Процесс (информатика)|процессы]], [[класс (объектно-ориентированное программирование)|классы]], базы знаний) — аналогично разнообразным математическим исчислениям (''см. также'' [[#Концептуальная целостность языков|концептуальная целостность языков]]). Поэтому такие языки нередко рассматриваются в роли [[предметно-специфичный язык|предметно-специфичных]] — на них выглядят простыми некоторые (но далеко не все) задачи, которые на других языках выглядят сложными. Однако расширение функциональности в других аспектах на этих языках может оборачиваться затруднениями. {{nobr|[[Standard ML]]}} и его родственники расслаиваются на два языка, из которых один — «''язык-ядро''» ({{lang-en|core language}}) — ориентирован на разработку простых программ, а другой — «[[язык модулей ML|язык модулей]]» ({{lang-en|module language}}),— соответственно, на нелинейную компоновку их в сложные программные системы. Со временем были построены варианты слияния их воедино ([[язык модулей ML#1ML|1ML]]). Многие другие языки также включают [[система модулей|системы модулей]], но большинство из них являются ''языками модулей первого порядка''{{переход|#Языки первого и высшего порядка|text}}. [[Язык модулей ML]] является единственным в своём роде ''языком модулей высшего порядка''{{переход|#Языки первого и высшего порядка|text}}. Языки [[Lisp]] и [[Forth]] позволяют наращивать системы произвольно и безгранично, в том числе позволяя создавать встраиваемые предметно-специфичные языки внутри себя (как своё синтаксическое и семантическое подмножество) — поэтому их нередко называют [[метаязык]]ами.

Наиболее популярным на сегодняшний день подходом к решению проблемы комплексирования является [[объектно-ориентированное программирование]], хотя успешность его применения на протяжении десятилетий существования неоднократно подвергалась скепсису, и до сих пор отсутствуют достоверные данные о том, что он приносит выигрыш по сравнению с другими подходами по тем или иным [[качество ПО|показателям качества]]. Ему сопутствуют (а порой конкурируют) различные технологии регламентирования зависимостей между компонентами: [[метакласс]]ы, [[контрактное программирование|контракты]], [[прототипное программирование|прототипы]], [[примесь (программирование)|примеси]], [[Типаж (абстрактный тип)|типажи]] и др.

Более мощным подходом исторически считалось использование различных форм [[метапрограммирование|метапрограммирования]], то есть автоматизации самого процесса разработки на различных уровнях. Принципиально различается метапрограммирование ''внешнее'' по отношению к языку и доступное в ''самом'' языке. При использовании языков первого порядка{{переход|#Языки первого и высшего порядка|text}} сложность растущих программных систем быстро переходит порог способностей человека по восприятию и переработке информации, поэтому применяются ''внешние'' средства предварительного [[визуальное программирование|визуального проектирования]], позволяющие обозревать сложные схемы в упрощённом виде и в уменьшенном масштабе и затем [[порождающее программирование|автоматически порождать]] каркас кода — см. [[CASE]]. В сообществах разработчиков, использующих языки высшего порядка{{переход|#Языки первого и высшего порядка|text}}, доминирует прямо противоположный подход — пресекать саму возможность выхода сложности из-под контроля за счёт разделения информационных моделей на независимые составляющие и разработки средств автоматического преобразования одних моделей в другие — см. [[языково-ориентированное программирование]].

=== {{якорь|Математически обоснованные языки программирования|Концептуальная целостность языков}} Концептуальная целостность языков ===
[[Фредерик Брукс]]{{sfn|Брукс|1975, 1995|loc=Достижение концептуальной целостности|с=30}} и [[Хоар, Чарльз Энтони Ричард|Ч. Э. Р. Хоар]]<ref>C.A.R. Hoare — The Emperor’s Old Clothes, Communications of the ACM, 1981</ref> делают акцент на необходимости обеспечения ''концептуальной целостности'' информационных систем вообще и языков программирования в частности, чтобы в каждой части системы использовались сходные синтаксические и семантические формы и не требовалось осваивать помимо собственно состава системы также и правила её [[идиома (программирование)|идиоматического]] использования. Хоар предсказывал, что сложность Ады станет причиной катастроф. [[Кэй, Алан Куртис|Алан Кэй]] отделяет языки, являющиеся «стилем во плоти» ({{lang-en|crystalization of style}}) от прочих языков, являющихся «склеиванием возможностей» ({{lang-en|agglutination of features}})<ref>{{статья
 | автор = [[Кэй, Алан Куртис|Алан Кэй]]
 | заглавие = The Early History of Smalltalk
 | издательство = Apple Computer, ACM SIGPLAN Notices, vol.28, № 3
 | год = March 1993
 | ссылка = http://stephane.ducasse.free.fr/FreeBooks/SmalltalkHistoryHOPL.pdf
 | archivedate = 2012-09-14
 | archiveurl = https://web.archive.org/web/20120914083529/http://stephane.ducasse.free.fr/FreeBooks/SmalltalkHistoryHOPL.pdf
 }}</ref>. Грег Нельсон<ref name="Greg Nelson">{{книга
 | автор         = Greg Nelson
 | заглавие      = Systems Programming with Modula-3
 | ссылка       = https://archive.org/details/systemsprogrammi0000unse
 | место         = NJ
 | издательство  = Prentice Hall, Englewood Cliffs
 | год           = 1991
 | страниц       = 288
 | isbn          = 978-0135904640
}}</ref> и {{iw|Аппель, Эндрю|Эндрю Аппель|en|Andrew Appel}}{{sfn|Appel - A Critique of Standard ML|1992|}} выделяют в особую категорию «''языки, наследованные от математики''» ({{lang-en|mathematically-derived languages}}).

Эти акценты призывают к использованию языков, воплощающих некое математическое исчисление, аккуратно адаптированное для того, чтобы быть более практичным языком для разработки реальных программ. Такие языки отличаются [[Ортогональность (программирование)|ортогональностью]], и хотя это означает необходимость вручную реализовывать многие распространённые [[Идиома (программирование)|идиомы]], доступные в более популярных языках в качестве примитивов языка, [[Выразительность (программирование)|выразительность]] таких языков в целом может быть существенно выше.

Лишь некоторые языки попадают под эту категорию; большинство же языков проектируются приоритетно исходя из возможности эффективной трансляции в [[Машина Тьюринга|машину Тьюринга]]. Многие языки опираются на общие теории, но при разработке они почти никогда не проверяются на безопасность совместного использования конкретных языковых элементов, являющихся частными приложениями этих теорий, что неизбежно приводит к несовместимости между реализациями языка. Эти проблемы либо игнорируются, либо начинают преподноситься как естественное явление ({{lang-en|«not a bug, but a feature»}}), но в действительности их причиной является то, что язык не был подвергнут математическому анализу{{sfn|Commentary on SML|1991|с=vii|loc=Aims of the Commentary}}.

Примеры математически обоснованных языков и воплощаемых ими математических моделей:
<!-- можно оформить в виде таблицы из двух колонок: | язык | воплощаемая математическая модель | -->

* [[Agda]], {{iw|Epigram (язык программирования)|Epigram|en|Epigram (programming language)}}, [[Idris (язык программирования)|Idris]] — [[интуиционистская теория типов]] [[Мартин-Лёф, Пер|Мартин-Лёфа]].
* [[APL (язык программирования)|APL]] и его потомки ([[J (язык программирования)|J]], [[K (язык программирования)|K]]) — оригинальная семантика, не имеющая названия, воплощающая нотацию [[Айверсон, Кеннет|Айверсона]] для исчисления [[Массив (программирование)|массивов]] (часто встречается термин «{{lang-en2|array languages}}»).
* [[Coq]] — [[Исчисление конструкций|исчисление индуктивных конструкций]].
* [[Erlang]] — [[исчисление процессов]] (первоначально в форме [[модель акторов|модели акторов]], позже также построено обоснование на [[Пи-исчисление|<math>\pi</math>-исчислении]]<ref>{{статья
|автор = Thomas Noll, Chanchal Kumar Roy
|заглавие = Modeling Erlang in the Pi–Calculus
|издательство = ACM 1-59593-066-3/05/0009
|год = 2005
|ссылка = http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.113.3913&rep=rep1&type=pdf
|archivedate = 2014-08-01
|archiveurl = https://web.archive.org/web/20140801110556/http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.113.3913&rep=rep1&type=pdf
}}</ref>).
* [[Forth]] — {{iw|стековая машина||en|Stack machine}} и [[конкатенативный язык программирования]].
* [[Haskell]] — [[теория категорий]] (включая «декартово замкнутую категорию», воплощающую [[лямбда-исчисление]]; категорию [[монада (программирование)|монад]] для моделирования [[побочный эффект (программирование)|побочных эффектов]]; расширение [[система типов Хиндли — Милнера|системы типов Хиндли — Милнера]]; [[Род (теория типов)|систему родо́в]]; и др.).
* [[Joy (язык программирования)|Joy]] — [[композиция функций]] и [[гомоморфизм]] (иначе говоря, чистый [[конкатенативный язык программирования]] и, как следствие, [[чистота языка программирования|чистый функциональный]]).
* [[Lisp]] — [[лямбда-исчисление]] [[Чёрч, Алонзо|Чёрча]] (в том числе язык [[S-выражение|S-выражений]], воплощающий [[Кодирование Чёрча|нотацию пар Чёрча]]).
** [[Scheme (язык программирования)|Scheme]] — «облагороженный» диалект Лиспа ([[Сильная и слабая типизация|сильнее]] типизированный, в большей степени [[Гомоиконичность|гомоиконичный]], ограничивающийся {{iw|Гигиенические макроопределения|гигиеническими макроопределениями|en|Hygienic macro}} и соблюдающий {{iw|Числовая башня|числовую башню|en|Numerical tower}}), дополненный нотацией [[продолжение (программирование)|продолжений]].
* [[ML]] — [[типизированное лямбда-исчисление]], то есть [[лямбда-исчисление]], дополненное [[система типов Хиндли — Милнера|системой типов Хиндли — Милнера]].
* [[Prolog]] — [[исчисление предикатов]].
** [[Mercury (язык программирования)|Mercury]] — [[исчисление предикатов]], дополненное [[система типов Хиндли — Милнера|системой типов Хиндли — Милнера]].
* [[Smalltalk]] — [[теория множеств]]<ref>{{Cite web |url=http://c2.com/cgi/wiki?DesignPrinciplesBehindSmalltalk |title=Design Principles Behind Smalltalk |access-date=2014-06-03 |archive-date=2014-06-19 |archive-url=https://web.archive.org/web/20140619201155/http://c2.com/cgi/wiki?DesignPrinciplesBehindSmalltalk |url-status=live }}</ref> (с соблюдением {{iw|Числовая башня|числовой башни|en|Numerical tower}}).
* [[SQL]] — [[исчисление кортежей]] (вариант [[Реляционное исчисление|реляционного исчисления]], в свою очередь основанного на [[логика первого порядка|исчислении предикатов первого порядка]]).
* [[SGML]] и его потомки ([[HTML]], [[XML]]) — нотация [[дерево (структура данных)|деревьев]] (важный случай [[граф (математика)|графов]]).
* [[Unlambda]] — [[комбинаторная логика]].
* [[Регулярные выражения]]<!-- при оформлении в виде таблицы в правой колонке пишем: «[[Регулярные выражения]], ваш К. О.», либо соединяем всю строку в одну ячейку -->.
* [[Рефал]] — оригинальная семантика [[Турчин, Валентин Фёдорович|Турчина]], носящая название «''Рефал-машины''» или «''Рефал-автомата''», созданная на основе [[Нормальный алгоритм|нормального алгоритма]] [[Марков, Андрей Андреевич (младший)|Маркова]], воплощающая композицию [[теория автоматов|теории автоматов]], [[сопоставление с образцом|сопоставления с образцом]] и [[Переписывание|переписывания термов]].

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

* Существенное повышение стабильности программ. В одних случаях — за счёт построения доказательства надёжности для самого языка (см. [[типобезопасность]]), существенного упрощения [[Формальная верификация|формальной верификации]] программ и даже получения языка, который сам является [[Автоматическое доказательство|системой автоматического доказательства]] ([[Coq]], [[Agda]]). В других случаях — за счёт раннего обнаружения ошибок на первых же пробных запусках программ ([[Forth]] и [[регулярные выражения]]).
* Обеспечение ''потенциально'' более высокой эффективности программ. Даже если семантика языка далека от архитектуры целевой платформы компиляции, к нему могут быть применимы формальные методики [[Анализ потока управления|глобального анализа]] программ (хотя трудоёмкость написания даже тривиального транслятора может оказаться выше). Например, для языков [[Scheme (язык программирования)|Scheme]] и [[Standard ML]] существуют развитые [[Межпроцедурная оптимизация|полнопрограммно-оптимизирующие]] компиляторы и [[суперкомпиляция|суперкомпиляторы]], результат работы которых может уверенно конкурировать по скорости с языком низкого уровня [[Си (язык программирования)|Си]] и даже опережать последний (хотя ресурсоёмкость работы самих компиляторов оказывается значительно выше). Одна из самых быстрых [[СУБД]] — KDB<ref>{{Cite web |url=http://kx.com/benchmarks.php |title=kx: Calibrated performance |access-date=2014-06-03 |archive-date=2014-06-21 |archive-url=https://web.archive.org/web/20140621031329/http://kx.com/benchmarks.php |url-status=live }}</ref> — написана на языке [[K (язык программирования)|K]]. Язык [[Scala (язык программирования)|Scala]] (унаследовавший математику от [[ML]]) обеспечивает на платформе [[JVM]] более высокую скорость, чем «родной» для неё язык [[Java]]{{нет АИ|23|01|2017}}. С другой стороны, [[Forth]] имеет репутацию одного из самых нетребовательных к ресурсам языков (менее требователен, чем [[Си (язык программирования)|Си]]) и используется для разработки приложений реального времени под самые маломощные ЭВМ; кроме того, транслятор Форта является одним из наименее трудоёмких в реализации на [[ассемблер]]е.
* Заранее известный (неограниченный или, наоборот, чётко очерченный) предел роста сложности программных компонентов, систем и комплексов, которые можно выразить средствами этого языка с сохранением показателей [[качество программного обеспечения|качества]]{{sfn|Appel - A Critique of Standard ML|1992|}}<ref name="Luca Cardelli">{{статья
 | заглавие = Typeful programming
 | автор = Luca Cardelli
 | издательство = IFIP State-of-the-Art Reports, Springer-Verlag
 | год = 1991
 | ссылка = http://www.lucacardelli.name/Papers/TypefulProg.pdf
 | archivedate = 2016-03-22
 | archiveurl = https://web.archive.org/web/20160322112959/http://lucacardelli.name/Papers/TypefulProg.pdf
 }}</ref>. Языки, не имеющие математического обоснования (а именно такие наиболее часто применяются в [[мейнстрим]]е: [[C++]], [[Java]], [[C Sharp|C#]], [[Delphi (язык программирования)|Delphi]] и др.), на практике ограничивают реализуемую функциональность и/или снижают качество по мере усложнения системы{{sfn|Ward|1994|quote=There is a fundamental limit to complexity of any software system for it to be still manageable: if it requires more than «one brainfull» of information to understand a component of the system, then that component will ''not'' be understood fully. It will be extremely difficult to make enhancements or ﬁx bugs, and each ﬁx is likely to introduce further errors due to this incomplete knowledge.}}, так как им присущи экспоненциальные кривые роста сложности как относительно работы одного отдельно взятого человека, так и относительно сложности управления проектом в целом{{sfn|Брукс|1975, 1995}}{{sfn|Гласс|2004}}. ''Прогнозируемая'' сложность системы приводит либо к поэтапной декомпозиции проекта на множество более мелких задач, каждая из которых решается соответствующим языком, либо к [[Языково-ориентированное программирование#Подход|языково-ориентированному программированию]] для случая, когда адресуемой языком задачей является как раз [[семантика (программирование)|описание семантик]] и/или [[символьные вычисления]] ([[Lisp]], [[ML]], [[Haskell]], [[Рефал]], [[Регулярные выражения]]). Языки с неограниченным пределом роста сложности программ нередко относят к [[метаязык]]ам (что в непосредственном толковании термина не верно, но практике сводимо, так как всякий [[мини-язык]], выбранный для решения некоторой подзадачи в составе общей задачи, может быть представлен в виде синтаксического и семантического подмножества данного языка, не требуя [[транслятор|трансляции]]{{sfn|Czarnecki et al|2004}}).

* Удобство для человека при решении задач, на которые этот язык ориентирован по своей природе (см. [[проблемно-ориентированный язык]]), что в некоторой степени также способно (косвенно) повлиять на повышение стабильности результирующих программ за счёт повышения вероятности обнаружения ошибок в исходном коде и снижения дублирования кода.

=== Особые категории языков ===
* [[Учебный язык программирования|Учебные]]
* [[Предметно-специфичный язык|Предметно-специфичные]]
* [[Эзотерические языки программирования|Эзотерические]]
* [[Визуальное программирование|Визуальные]]

== Формальные преобразования и оптимизация {{якорь|Эффективность языков}} ==
[[Турчин, Валентин Фёдорович|В. Ф. Турчин]] отмечает<ref>Турчин В. Ф. Эквивалентные преобразования программ на РЕФАЛе: Труды ЦНИПИАСС 6: ЦНИПИАСС, 1974.</ref>, что достоинства всякого формализованного языка определяются не только тем, сколь он удобен для непосредственного использования человеком, но и тем, в какой степени тексты на этом языке поддаются формальным преобразованиям.

Например, [[ссылочная прозрачность]] означает, что [[Параметр (программирование)|параметры]] функций не обязаны вычисляться перед вызовом — вместо этого фактически переданное выражение может быть целиком подставлено на место переменной в функции, и поведение функции от этого не изменится. Это открывает возможности почти произвольных {{iw|Преобразование программ|автоматических преобразований программ|en|Program transformation}}: могут устраняться ненужные промежуточные представления данных, редуцироваться сложные цепочки вычислений, подбираться оптимальное количество [[параллельные вычисления|параллельных процессов]], вводиться [[мемоизация]], и пр. С другой стороны, это означает полное отсутствие [[побочный эффект (программирование)|побочных эффектов]], а это делает реализацию некоторых алгоритмов заведомо менее эффективной, чем при использовании [[состояние (информатика)|изменяемого состояния]].

Для небольших и простых программ языки высокого уровня порождают машинный код большего размера и исполняются медленнее. Однако для алгоритмически и структурно сложных программ преимущество может быть на стороне некоторых языков высокого уровня, так как человек физически не способен выражать сложные концепции с учётом их эффективного исполнения на языке машины. К примеру, существует [[Тест производительности|бенчмарк]], на котором [[MLton]] и {{iw|Stalin Scheme||en|Stalin (Scheme implementation)}} уверенно опережают [[GCC]]<!-- ffconsultancy: Ray Tracer Language Benchmark -->. Есть масса частных причин, по которым [[оптимизирующий компилятор|автоматическая оптимизация]] в ходе трансляции языков высокого уровня даёт ''в принципе'' более высокую скорость исполнения, чем сознательный контроль способа реализации на языках низкого уровня. Например, имеются достоверные данные о том, что автоматическое управление памятью более эффективно, чем ручное, уже только при использовании динамического метода (см. [[сборка мусора]])<ref>{{статья
| автор = B. Zorn.
| заглавие = The Measured Cost of Conservative Garbage Collection. Technical Report CU-CS-573-92.
| издание = University of Colorado at Boulder
| год = 1993
| doi = 10.1.1.14.1816
}}</ref>, а существует и потенциально более эффективный статический метод (см. [[управление памятью на основе регионов]]). Далее, для каждого микроконтекста необходимо распределить [[Регистр процессора|регистры]] с учётом минимизации обращения к памяти, а это требует решения [[раскраска графа|задачи раскраски графа]]. Такого рода особенностей машинной логики очень много, так что общая информационная сложность возрастает экспоненциально при каждом «шаге на уровень вниз», а компиляция языка высокого уровня может включать ''десятки'' таких шагов.

Существует множество стратегий [[оптимизирующий компилятор|автоматической оптимизации]]. Некоторые универсальны, другие могут быть применимы лишь к языкам определённой природы, а некоторые зависят от ''способа использования'' языка. Примером может служить [[оптимизация хвостовых вызовов]] и её частный случай — [[оптимизация хвостовой рекурсии]]. Хотя компиляторы многих языков осуществляют оптимизацию хвостовой ''рекурсии'' при определённых условиях, лишь некоторые языки способны семантически гарантировать оптимизацию хвостовых ''вызовов'' в общем случае. Стандарт языка [[Scheme (язык программирования)|Scheme]] ''требует'', чтобы всякая реализация гарантировала её. Для многих [[Функциональное программирование|функциональных языков]] она в принципе применима, но лишь [[оптимизирующий компилятор|оптимизирующие компиляторы]] её выполняют. В языках вроде [[Си (язык программирования)|Си]] или [[C++]] она может производиться лишь в определённых случаях и лишь при использовании глобального [[Анализ потока управления|анализа потока управления]]{{sfn|Ehud Lamm|}}.

Языки высшего порядка в большинстве случаев вынуждены исполняться медленнее, чем языки первого порядка. Причины лежат как в самой декомпозиции линейного кода на цепочку вложенных вызовов, так и в вытекающих особенностях низкоуровневого представления функций (см. [[Замыкание (программирование)|замыкание]]) и данных (обёрнутое ({{lang-en|boxed}}), теговое). Однако существуют техники агрессивной [[оптимизирующий компилятор|оптимизации программ]], позволяющие редуцировать языки высшего порядка до языков первого порядка (см. [[дефункционализация]], [[MLton]], {{iw|Stalin Scheme||en|Stalin (Scheme implementation)}}).

== Популярность языков ==
{{main|:en:Measuring programming language popularity|l1=Измерение популярности языков{{ref-en}}}}
{{see|Индекс TIOBE}}

Трудно определить, какой язык программирования наиболее популярен, так как значение слова «популярность» зависит от контекста (в английском языке используется термин «usage», имеющий ещё более размытое значение). Один язык может отнимать наибольшее количество [[человеко-час]]ов, на другом написано наибольшее число строк кода, третий занимает наибольшее [[процессорное время]], а четвёртый наиболее часто служит исследовательской базой в академических кругах. Некоторые языки очень популярны для конкретных задач. Например, [[Кобол]] до сих пор доминирует в корпоративных [[дата-центр]]ах, [[Фортран]] — в научных и инженерных приложениях, вариации языка [[Си (язык программирования)|Си]] — в [[системное программирование|системном программировании]], а различные потомки [[ML]] — в [[формальная верификация|формальной верификации]]{{нет АИ|24|12|2016}}. Другие языки регулярно используются для создания самых разнообразных приложений.

Существуют различные метрики для измерения популярности языков, каждая из которых разработана с пристрастием к определённому смыслу понятия популярности:
* подсчёт числа вакансий, упоминающих язык;
* количество проданных книг (учебников или справочников);
* оценка количества строк кода, написанных на языке (что не принимает в расчёт редко публикуемые случаи использования языков);
* подсчёт упоминаний языка в запросах [[Поисковая система|поисковиков]].

Следует заметить, что высокие оценки по этим показателям не только никак не свидетельствуют о высоком техническом уровне языка и/или оптимизации расходов при его использовании, но и, напротив, порой могут говорить об обратном. Например, язык [[Кобол]] входит в число лидеров по количеству написанных на нём строк кода, но причиной этому является крайне низкий показатель модифицируемости кода, что делает этот код не [[повторное использование кода|повторно используемым]], а [[Унаследованная система|legacy-кодом]]. Как следствие, поддержка программ на [[Кобол]]е в кратковременной перспективе обходится значительно дороже, чем программ на большинстве современных языков, но переписывание их с нуля потребовало бы значительных единовременных вложений и может сравниваться только с долговременными расходами. Техническое несовершенство Кобола обусловлено тем, что его разрабатывали без привлечения экспертов в области информатики<ref>{{статья
|заглавие=Cobol, your age is showing
|издание=[[Computerworld Россия|Computerworld]]
|издательство=[[International Data Group]]
|том=18
|номер=20
|страницы=ID/7—ID/18
|ссылка=https://books.google.com/books?id=BrEo9KtAQH4C&pg=RA1-PA61
|issn=0010-4841
|язык=en
|автор=Richard L. Conner
|число=14
|месяц=5
|год=1984
|тип=magazine}}</ref><ref>{{cite web
| author = Robert L. Mitchell
| title = Cobol: Not Dead Yet
| work = Computerworld
| url = http://www.computerworld.com/s/article/266156/Cobol_Not_Dead_Yet
| date = 2006-10-04
| accessdate = 2014-04-27
| archive-date = 2014-04-27
| archive-url = https://web.archive.org/web/20140427203356/http://www.computerworld.com/s/article/266156/Cobol_Not_Dead_Yet
| url-status = live
}}</ref>.
<!-- НЕОБХОДИМО НАПИСАТЬ ТАКОЕ ЖЕ ПРО C++!!! -->

== См. также ==
* [[Компьютерный язык]]
* [[Программирование]]
* [[Hello, world!]]
* [[Стандарт оформления кода]]
* [[Теория языка программирования]]

== Примечания ==
{{примечания|2}}

== Литература ==
* {{книга| автор = Гавриков М. М., Иванченко А. Н., Гринченков Д. В.
| заглавие = Теоретические основы разработки и реализации языков программирования
| издательство = [[КноРус]]
| год = 2013
| isbn = 978-5-406-02430-0
| страниц = 178
| ref = Гавриков
}}

* {{книга| автор = Криницкий Н. А., Миронов Г. А., Фролов Г. Д.
| заглавие = Программирование
| издательство = ГИФМЛ
| год = 1963
| isbn = 
| страниц = 384
| ref = Криницкий
}}

* {{книга| автор = Братчиков И. Л.
| заглавие = Синтаксис языков программирования
| издательство = [[Наука (издательство)|Наука]]
| год = 1975
| isbn = 
| страниц = 230
| ref = Братчиков
}}

* {{книга| автор = [[Лавров, Святослав Сергеевич|Лавров С. С.]]
| заглавие = Основные понятия и конструкции языков программирования
| издательство = Финансы и статистика
| год = 1982
| isbn = 
| страниц = 80
| ref = Лавров
}}

* {{статья|автор=Christopher Strachey.|заглавие=Fundamental Concepts in Programming Languages|ссылка=http://www.itu.dk/courses/BPRD/E2009/fundamental-1967.pdf|язык={{ref-en}}|год=1967|ref=Strachey — Fundamental Concepts|издание=|archiveurl=https://web.archive.org/web/20170812012310/http://www.itu.dk/courses/BPRD/E2009/fundamental-1967.pdf|archivedate=2017-08-12}}
** Повторно опубликовано: {{статья
| автор = Christopher Strachey.
| заглавие = Fundamental Concepts in Programming Languages
| издание = [[Higher-Order and Symbolic Computation]]
| язык ={{ref-en}}
| том = 13
| страницы = 11—49
| год = 2000
| doi = 10.1023/A:1010000313106
|issn = 1388-3690 }}

* {{книга
| автор = Харольд Абельсон, Джеральд Джей Сассман, Джули Сассман.
| заглавие = [[Структура и интерпретация компьютерных программ]] (SICP)
| ref = SICP
}}

* {{h}}{{книга
| автор = [[Брукс, Фредерик|Фредерик Брукс]].
| заглавие = [[Мифический человеко-месяц|Мифический человеко-месяц или Как создаются программные системы]]
| издательство = [[Addison-Wesley]]
| год = 1975, 1995
| isbn = ISBN 5-93286-005-7 (1-е изд.)
| ref = Брукс
}}

* {{книга
| автор = Теренс Пратт.
| заглавие = Языки программирования: разработка и реализация
| оригинал = Programming Language Design and Implementation (PLDI)
| издание = 1-е издание
| издательство = [[Мир (издательство)|Мир]]
| год = 1979
| страниц =
| ref = Пратт
}}

* {{книга
| автор = Альфред Ахо, Рави Сети, Джеффри Ульман.
| заглавие = Компиляторы: принципы, технологии и инструменты
| издание =
| издательство = Addison-Wesley Publishing Company, Издательский дом «Вильямс»
| год = 1985, 2001, 2003
| страниц = 768
| isbn = 5-8459-0189-8 (рус.), 0-201-10088-6 (ориг.)
| ссылка =
| ref = Ахо, Сети, Ульман
}}

* {{Книга
|автор = Time-Life Books.
|заглавие = Язык компьютера
|место = М.
|издательство = Мир
|год = 1989
|страниц = 240
|isbn = 5-03-001148-X
|оригинал = Computer Languages
|тираж = 100000
|ref = Computer Languages
|серия = Understanding Computers
|том = 2
}}

* {{статья
| автор         = {{iw|Карделли, Лука|Лука Карделли|en|Luca Cardelli}}.
| заглавие      = Typeful programming
| ссылка        = http://www.lucacardelli.name/Papers/TypefulProg.pdf
| язык          ={{ref-en}}
| издание       = IFIP State-of-the-Art Reports
| издательство  = Springer-Verlag
| год           = 1991
| выпуск        = Formal Description of Programming Concepts
| страницы      = 431—507
| ref           = Cardelli - Typeful programming
}}

* {{статья
| автор = [[Милнер, Робин|Robin Milner]], {{iw|Mads Tofte}}.
| заглавие = Commentary on Standard ML
| издательство = MIT Press
| год = 1991
| ISBN = 0-262-63132-7
| ссылка = https://www.itu.dk/people/tofte/publ/1990sml/1991commentaryBody.pdf
| ref = Commentary on SML
| издание = 
| archiveurl = https://web.archive.org/web/20141201213417/https://www.itu.dk/people/tofte/publ/1990sml/1991commentaryBody.pdf
| archivedate = 2014-12-01
}}

* {{книга
| автор = Альфред Ахо, Джеффри Ульман.
| заглавие =  Foundations of Computer Science
| издание =
| издательство = Computer Science Press
| год = 1992
| страниц =
| isbn =
| ссылка =
| ref = Ахо, Ульман
}}

* {{статья
| автор = Andrew W. Appel.
| заглавие = A Critique of Standard ML
| издательство = Princeton University, revised version of CS-TR-364-92
| год = 1992
| ссылка = http://www.cs.princeton.edu/research/techreps/TR-364-92
| ref = Appel - A Critique of Standard ML
}}

* {{статья
| автор = [http://www.cse.dmu.ac.uk/~mward/ Martin Ward].
| заглавие = Language Oriented Programming
| издательство = Computer Science Department, Science Labs
| год = 1994
| ссылка = http://www.cse.dmu.ac.uk/~mward/martin/papers/middle-out-t.pdf
| ref = Ward
}}

* {{статья
| автор = Ian Joyner.
| заглавие = A Critique of C++ and Programming and Language Trends of the 1990s - 3rd Edition.
| ссылка = http://www.quinn.echidna.id.au/quinn/C++-Critique-3ed.pdf
| издание = [http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/cppcrit/index008.htm копирайт и список изданий]
| год = 1996
| ref = Joyner
}}

* {{книга|автор={{iw|Полсон, Лоуренс|Lawrence C. Paulson|en|Lawrence Paulson}}.|заглавие=ML for the Working Programmer|издание=2nd|место=Cambridge, Great Britain|издательство=Cambridge University Press|год=1996|страниц=492|isbn=0-521-57050-6 (твёрдый переплёт), 0-521-56543-X (мягкий переплёт)|ref=Paulson, «ML for the Working Programmer»}}
* {{книга|автор=John C. Reynolds.|заглавие=Theories of programming languages|издательство=Cambridge University Press|год=1998|isbn=978-0-521-59414-1 (hardback), 978-0-521-10697-9 (paperback)|ссылка=http://booksee.org/book/696403|ref=Reynolds, «Theories of programming languages»}}
* {{книга
| автор = Andrew W. Appel.
| заглавие = Modern compiler implementation in ML (in C, in Java)
| издание =
| язык ={{ref-en}}
| место = Cambridge, Great Britain
| издательство = Cambridge University Press
| год = 1998
| страниц = 538
| isbn = (ML) 0-521-58274-1 (hardback), 0-521-60764-7 (paperback)
| ссылка =
| ref = Appel, "Modern compiler implementation"
}}

* {{статья
| автор = Paul Hudak
| заглавие = Modular Domain Speciﬁc Languages and Tools
| издательство = IEEE Computer Society Press, Department of Computer Science, Yale University
| год = 1998
| ссылка = http://haskell.cs.yale.edu/?post_type=publication&p=125
| ref = Hudak
| издание = 
| archiveurl = https://web.archive.org/web/20131017021928/http://haskell.cs.yale.edu/?post_type=publication&p=125
| archivedate = 2013-10-17
}}

* {{Книга|автор=Роберт У. Себеста.|заглавие=Основные концепции языков программирования|оригинал=Concepts of Programming Languages|ответственный=Пер. с англ|издание=5-е изд|место=М.|издательство=[[Вильямс (издательство)|Вильямс]]|год=2001|страниц=672|isbn=5-8459-0192-8 (рус.), ISBN 0-201-75295-6 (англ.)|тираж=5000}}
* {{Книга|автор=Вольфенгаген В. Э.|заглавие=Конструкции языков программирования. Приёмы описания|место=М.|издательство=Центр ЮрИнфоР|год=2001|страниц=276|isbn=5-89158-079-9}}
* {{Книга|автор=Паронджанов В. Д.|заглавие=Как улучшить работу ума. Алгоритмы без программистов — это очень просто! |nodot=1|место=М.|издательство=Дело|год=2001|страниц=360|isbn=5-7749-0211-0}}
* {{книга
| автор         = Pierce, Benjamin C.
| заглавие      = Types and Programming Languages
| ссылка        = http://www.cis.upenn.edu/~bcpierce/tapl/
| викитека      =
| издание       =
| издательство  = [[MIT Press]]
| год           = 2002
| isbn          = 0-262-16209-1
}}
** Перевод на русский язык: {{книга
| автор         = Пирс Б.
| заглавие      = Типы в языках программирования
| викитека      =
| ответственный =
| издание       =
| издательство  = [[Добросвет]]
| год           = 2012
| страниц       = 680
| isbn          = 978-5-7913-0082-9
| ref           = Pierce
}}

* {{книга
| автор = Теренс Пратт, Марвин Зелковиц.
| заглавие = Языки программирования: разработка и реализация
| оригинал =
| издание = 4-е издание
| издательство = Питер
| год = 2002
| страниц =
| серия = Классика Computer Science
| isbn = 978-5-318-00189-5
| ref = Пратт, Зелковиц
}}

* {{книга
|автор = Martin Campbell-Kelly.
|заглавие = From Airline Reservations to Sonic the Hedgehog: A History of the Software Industry
|ссылка = https://archive.org/details/fromairlinereser00mart_0
|издательство = MIT Press
|год = 2003
|страниц = 372
|isbn = 978-1422391761
|серия = History of Computing
|ref = Campbell-Kelly
}}

* {{книга
| автор = [[Гласс, Роберт|Роберт Гласс]]
| заглавие = Факты и заблуждения профессионального программирования
| ссылка = http://www.rsdn.ru/res/book/prog/Facts_and_Fallacies.xml
| издательство = «Символ-Плюс»
| год = 2004
| страниц = 240
| isbn = 5-93286-092-8, 978-5-93286-092-2
| ref = Гласс
}}

* {{книга
| автор = John C. Mitchell.
| заглавие = Concepts in Programming Languages
| издательство = Cambridge University Press
| год = 2004
| страниц =
| isbn = 0-511-04091-1 (eBook in netLibrary); 0-521-78098-5 (hardback)
| ссылка =
| ref = Mitchel
}}

* {{статья
| автор = K. Czarnecki, J. O’Donnell, J. Striegnitz, W. Taha.
| заглавие = DSL implementation in metaocaml, template haskell, and C++
| издательство = University of Waterloo, University of Glasgow, Research Centre Julich, Rice University
| год = 2004
| ссылка = http://camlunity.ru/swap/Library/Computer%20Science/Metaprogramming/Domain-Specific%20Languages/DSL%20Implementation%20in%20MetaOCaml,%20Template%20Haskell%20and%20C++.pdf
| ref = Czarnecki et al
| издание = 
| archiveurl = https://web.archive.org/web/20160305042746/http://camlunity.ru/swap/Library/Computer%20Science/Metaprogramming/Domain-Specific%20Languages/DSL%20Implementation%20in%20MetaOCaml,%20Template%20Haskell%20and%20C++.pdf
| archivedate = 2016-03-05
}}

* {{Книга
| автор = Ф. Бьянкуцци, Ш. Уорден.
| заглавие = Пионеры программирования. Диалоги с создателями наиболее популярных языков программирования
| место = СПб.
| издательство = [[Символ-Плюс]]
| год = 2010
| ссылка = http://www.symbol.ru/alphabet/792588.html
| страниц = 608
| isbn = 978-5-93286-170-7
| ref = Бьянкуцци, Уорден
}}

* {{книга
| автор = [http://c2.com/cgi/wiki?PeterSeibel Питер Сейбел].
| заглавие = Кодеры за работой. Размышления о ремесле программиста
| издание = Символ-Плюс, СПб
| год = 2011
| isbn = 978-5-93286-188-2, 978-1-4302-1948-4 (англ.)
| ref = Сейбел - Кодеры за работой
}}

* {{книга|автор={{iw|Харпер, Роберт (информатик)|Robert Harper|en|Robert Harper (computer scientist)}}.|заглавие=Practical Foundations for Programming Languages|издание=version 1.37 (revised 01.11.2014)|издательство=licensed under the Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License.|год=2012|страниц=544|ссылка=http://bookfi.org/book/1076504|ref=Harper — Practical Foundations for Programming Languages}} {{Wayback|url=http://bookfi.org/book/1076504 |date=20151024155104 }}
* {{статья
| автор = Marjan Mernik.
| заглавие = Formal and Practical Aspects of Domain-Specific Languages
| издательство  = IGI Global
| год = 2012
| isbn = 978-1-4666-2092-6
| ссылка = http://sharebookfree.com/formal-and-practical-aspects-of-domain-specific-languages-recent-developments/
| ref = Mernik
}}

== Ссылки ==
{{Навигация}}
* [https://web.archive.org/web/20040612042127/http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm The Language List]{{недоступная ссылка|http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm}}{{ref-en}} — более 2500 языков с кратким описанием
* [http://www.levenez.com/lang/ Computer Languages History]{{ref-en}} — история языков программирования (с 1954 по май 2004) (содержит регулярно обновляемую диаграмму)
* [https://web.archive.org/web/20040404130307/http://www.ntecs.de/old-hp/uu9r/lang/html/lang.en.html Examples]{{недоступная ссылка|http://www.ntecs.de/old-hp/uu9r/lang/html/lang.en.html}}{{ref-en}} — примеры программирования на 162 языках
* [https://web.archive.org/web/20140226220709/http://langpop.com/ Programming Language Popularity]{{ref-en}} — регулярно обновляемое исследование популярности языков программирования
* [http://www.realcoding.net/articles/10-yazykov-programmirovanie-kotorye-stoit-izuchat.html 10 языков программирования, которые стоит изучать (2006 г.)] {{Wayback|url=http://www.realcoding.net/articles/10-yazykov-programmirovanie-kotorye-stoit-izuchat.html |date=20111109145039 }}
* [http://www.tiobe.com/tpci.htm Programming Community Index]{{ref-en}} — регулярно обновляемый рейтинг популярности языков программирования
* [https://web.archive.org/web/20090627025632/http://shootout.alioth.debian.org/ Computer Language Shootout Benchmarks]{{недоступная ссылка|http://shootout.alioth.debian.org/}}{{ref-en}} — сравнение языков программирования по эффективности
* [http://bluebones.net/2004/04/programming-languages-that-are-loved/ Programming Languages that are Loved]{{ref-en}} — сравнение языков программирования по «любви» и «ненависти» к ним
* {{статья |url=http://wiki.lazarus.freepascal.org/Why_Pascal_is_Not_My_Favorite_Programming_Language |автор=[[Брайан Керниган]] |заглавие=Why Pascal is Not My Favorite Programming Language |год=1981 |ref=Kernigan about Pascal
}}
* {{cite web |url=http://lambda-the-ultimate.org/classic/message1532.html |title=Hidden complexities of tail-call/tail-recursion optimization |subtitle=LtU Classic Archives |author=Ehud Lamm |date=2003-12-07 |publisher=Lambda the Ultimate |accessdate=2016-11-30 |lang=en |description= |deadlink= |archiveurl= |archivedate= |ref=Ehud Lamm }}

{{внешние ссылки}}
{{Языки программирования}}
{{Нерабочие сноски|дата=2023-10-17}}

[[Категория:Языки программирования| ]]