Языки программирования

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

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

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

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

Самые первые языки, появившиеся в 50-е годы, относились к разным группам и занимали разные экологические ниши в мире программирования. Компьютеры тогда были до́роги, профессия программиста была редкостью, и было мало желающих создать новый язык, когда такой же точно язык уже есть.
Если кратко, то низкоуровневное программирование велось на всевозможных Автокодах, алгоритмы описывали на Алголе (откуда происходят процедурные языки и ООП), вычислительные программы делали на Фортране, и были ещё две ниши: декларативные языки, такие, как Лисп, и языки для описания бизнес-процессов, такие, как Кобол.
За прошедшие несколько десятилетий ничего не изменилось. Некоторые языки почти полностью повторяют своих предшественников, и различий между Паскалем и Алголом меньше, чем между разными диалектами Лиспа.
Они же автокоды. Очень близки к машинному коду, что позволяет при умелом программировании получить высокую скорость выполнения (но не разработки)ю
Знамениты тем, что написать код обычно быстрее, чем разобраться в существующем:
Прямые потомки Алгола-58, откуда убрали оператор перехода (вернее, научились обходиться без него, а на уровне машинных команд прыжки вперёд через участки кода по-прежнему есть). Программы на них представляют собой последовательности действий, от "«x := 2*2»" до "«господьБог.создатьВселенную()»":
— тысячи их! какой случайный язык, используемый (или использовавшийся) на практике, ни возьми — с высокой вероятностью он будет принадлежать к этой группе. Что и неудивительно: само название «Алгол» происходит от «Algorithmic Language», то есть язык для описания алгоритмов (но сам он, разделив судьбу птеродактилей, полетел в мир иной).
Язык C — особая мякотка. Несмотря на то, что он, строго говоря, является высокоуровневым языком, на фоне таких быдлоязычков, как Жаба или C# его называют низкоуровневым, так как уровень абстракций неприлично низок. Более того, именно на нем в 95% случаев пишут околосистемные вещи, вроде драйверов и ядер ОС, используя, впрочем, тонны ассемблерных вставок. Поэтому однозначно отнести его к какой-то категории, не вызвав бурления говн, невозможно. Иногда даже говорят, что C — «язык среднего уровня».
Это внезапно не Алгол! Языком прикладного программирования считали Фортран, на котором изначально предполагалось описывать вычислительные процессы. У него не было и до сих пор нет даже названия: «фортран» означает «транслятор формул», и так назывался не язык, а его компилятор. Изначально там не было даже правил видимости переменных, а все данные лежали в общей области данных: посчитал — и напечатал результат:
Иногда в прессе и на форумах поминают Фортран как что-то плохое. Возможно, так и было, но обижаться на то, что современные скриптовые языки происходят от него — глупость. Именно это направление развивалось больше всего (оно было прикладным) и именно на скриптах были обкатаны многие нововведения (такие, как словари), позже перенесённые в другие языки.
Лет 30-40 тому назад вопрос «Фортран или Алгол» был вполне насущным вопросом, и задавались им всерьёз. Даже был забытый ныне мем: «настоящие програмисты пишут на Фортране».
Они же «бизнес-ориентированные языки». Первоначально эту нишу занимал простецкий «Common Business-Oriented Language», который использовался в банках. Супермаркеты, ресторашки, кафэтэрии, склады, турагентства, таксопарки, железные дороги, госструктуры и т. п. — так до сих пор и используют его или один из его многочисленных диалектов:
А теперь о грустном, да. Кобол был выблядком среди других языков, и проклятие тяготело над ним с самого начала: данные хранились вместе с кодом и внутри кода, в блоках «var» в заголовках модулей — и там неизбежно накапливался мусор. Позже этот приём перешёл в языки Алгол и Паскаль, а всё это ваше современное ООП — нежизнеспособный гибрид Алгола с Коболом. И какие молитвы ни возноси разным там компиляторам — не взлетит, и всё тут.
Привет из 50-х, коллеги!
Самым первым языком, пришедшим в эту нишу, доселе необитаемую, был Лисп, и всё, что здесь тусуется — прямые его потомки. По-видимому, условия здесь настолько не подходят для жизни, что не дохнут только немногие языки. Программы на них представляют собой не набор команд, а описание процесса: не "что" делать, а "как" делать. Эту группу надо разделить на функциональные и логические, а также смешанные:
Лисп когда-то был автокодом в скобочной записи, но этим дело не ограничилось:
Изначально предназначались для создания экспертных систем aka искусственного интелекта. Но на практике, при попытке создать что-нибудь действительно полезное, выявились недостатки, которые привели к появлению гибридных функционально-логических языков.
Глубокая идея функциональных языков на самом деле гораздо глубже, чем кажется на первый взгляд. Джон Маккарти, автор Лиспа, перевернул всё программирование 50-х и 60-х годов с головы на ноги: он поставил на первое место не данные, вокруг которых суетятся мелкие программки (как гномы, прыгающие вокруг Белоснежки в диснеевском мультике), а сами эти программки. Данные же он предлагал протаскивать через цепочки выполнения, а язык для описания этого дела был назван «List Processor», то есть Язык Обработки Списков.
А ещё, люди, которые пишут на Коболе, не пишут на этих языках. Так что сохраняй ледяное спокойствие, Анон, выгребая очередную порцию лживых обещаний с какого-нибудь Х#$хантера.

Поскольку большая программа на олдовом процедурном языке по мере роста превращается в лютый пиздец размером с белого медведя при лисьей морде и лисьем же хвосте, возникли различные идеи по исправлению положения.
В разное время разным теоретикам приходили в голову разные умные мысли. Одни из этих идей вошли в арсенал процедурного программирования, другие остались чистой теорией, воплощённой в малоизвестных экзотических языках. В конце концов, практическое применение смогло найти ООП, оно же объектное программирование. Также особняком держится функциональное программирование.
Многие элементы языков программирования, кажущиеся естественными, на самом деле были придуманы не сразу и не в готовом виде.
Наиболее олдовая парадигма, в рамках которой и вывелся описанный выше песец, для борьбы с которым и придумали все прочие парадигмы.
Процедуры изобрёл ещё фон Нейман, до появления самих языков программирования, когда вычислительные устройства ползали и копошились где-то на уровне автомата Тьюринга. Идея заключалась в разделении больших программ на логически цельные подпрограммы (англ. "subroutine"), они же процедуры (англ. "procedure"), и во времена, когда компьютеры были большими, а программы маленькими, это изрядно помогало, но в конце концов разделения на процедуры оказалось недостаточно.
Придумано Дейкстрой, форсилось Виртом, придумка заключалась в дальнейшем разбиении кода подпрограмм на более мелкие фрагменты, а именно — на блоки "begin" и "end", а также в отказе от оператора перехода GoTo. Но, кстати, вложенные "begin" и "end" появились в Алголе раньше, чем Дейкстра придумал свою парадигму, то есть Алгол появился раньше, чем идея о том, каким он «должен» быть "(спойлер: "это потому, что Дейкстра участвовал в разработке Алгола")" . А ещё, в отличие от Алгола, в ранних реализациях Паскаля, который форсили как новейший структурный язык, дело с возможностью вложить в один "begin" и "end" сколько угодно других обстояло довольно туговато, так что он был шагом не вперёд, а назад…
Алсо, оператор GoTo стал на долгие годы предметом специальной олимпиады, в которой противники GoTo ссылались на Дейкстру, а сторонники — на Дональда Кнута. Сей именитый срач (со ссылкой на имена авторитетных теоретиков) постепенно затих с распространением ООП.
Несмотря на все усилия, олдовые программы по-прежнему представляли собой длиннющий непрерывный листинг, печатаемый на длинной ленте. Идея модульности заключалась в том, чтобы этот длиннющий код разбить на более короткие и логически цельные == более лёгкие для чтения и восприятия куски.
Изначально для этого был запилен аж целый язык — Modula, представляющий собой модифицированный Pascal. Затем те же фишки добавили в обычный Pascal, а затем возможность разбивать программы на отдельные модули появилась и в других языках. Так что теперь практически все языки являются модульными.
Появилось после того, как кто-то из хороших парней в стопицотый раз прошёлся по граблям с диким криком «почему йА». Идея заключалась в том, чтобы разделить код, разделить данные — а затем соединить соответствующие кусочки кода и данных. Но чтобы данные, ставшие ненужными — выбрасывались, в отличие от Кобола. Начальные подвижки к ООП появились уже в языке Simula, но первым объектно-ориентированным языком стал Smalltalk: собственно, его авторами и был введён сабжевый термин.
Однако кто-то что-то недопонял, поэтому Simula ВНЕЗАПНО обнаружила себя объектно-ориентированным языком, причем эталонным. Сначала ее недо-ООП слизал C++, а постепенно это веяние перешло и в другие языки. Самое смешное, что классическое ООП из Simula, используемое в Java, C#, C++ же и прочем мейнстриме, нихуя не канонично и имеет весьма мутное отношение к идеям, который вкладывались в ООП его создателями. Но всем как всегда.
ООП — не серебряная пуля и рядовому программистишке не даёт ничего. И при первой же возможности вырождается обратно в Кобол. "(спойлер: "Ведь проще всего, не думая, создать один-единственный класс на всю программу — и получается форменный Кобол с глобальными переменными.")" 
Все мейнстримовые языки сейчас — объектно-ориентированные. Так что применяется ООП почти везде, где надо и где не надо. Иногда — даже работает. Помимо классической C+±подобной реализации, характерные для C++ и потомков (Java, C#, но сходные вещи есть и в PHP), есть более мягкая реализация без приватных полей (Python, Ruby), чуть другое OOP через prototype (характерен для JavaScript, но средний веб-проггер на него забивает) и более хитрый и новомодный «через подмешивание» (Scala, Rust, Go). Последний грозятся добавить в C++, чтобы олдфаги точно на стенку полезли.
В своё время был эпичный срач, в котором олдфаги утверждали что любой алгоритм можно написать и без ООП, а потому оно не нужно. На что сторонники ООП утверждали, что ООП улучшает структуру программы, а «любой алгоритм» можно написать на любом тьюринг-полном языке, включая Brainfuck и Assembler. На это утверждение шёл ответ, что ООП не улучшает структуру, а превращает программу в mind-fuck с трудноуловимыми ошибками и утечками памяти. Что для нуба и в самом деле правда, и потому сторонники ООП это обвинение не только не отрицали, но и указывали на рукожопость и скудоумие, особенно популярным троллингом было «старую собаку не научишь новым фокусам». Финальную точку в сраче ВНЕЗАПНО поставила Windows с ее объектно-ориентированным WinAPI (ЧСХ, со своей реализацией ООП на C). Это был EPIC WIN ООП.
Конкретно соснувшие хуйца олдфаги возненавидели лично Билла Гейтса (который в общем-то объективно говоря ничем не хуже Стива Джобса), и стали дружно фапать на тогда ещё полностью консольный UNIX с его чисто процедурным POSIX, вызывавший у них слезу умиления и ностальгию по тем временам, когда ещё не было ненавистных им юзеров, сидящих на винде. Ну а вчерашнее школоло, студенты-первокурсники, не понимая, где ООП нужен, а где нет, попыталось сесть на оба этих взаимоисключающих стула сразу: с одной стороны, прониклись модным и крутым ООП, развивающимся под Windows же (sic!), а с другой — стали подражать олдфагам, ненавидящим Гейтса, без понимания причин этой ненависти. Вот так: весь этот ихний Масюкль — обезьянничание с ненавидимых и проклинаемых ими же технологий.
Постепенно роль основных критиков ООП перешла к фанатам Лиспа. Забавно, что волну погнал Джон Бэкус, автор Фортрана: получая премию Тьюринга, он высказался в том смысле, прямо со сцены, что «все эти годы мы писали код неправильно». И вот недавно Micro$oft (уже без Била Гейтса) выпустила гибрид ежа с ужом — язык F#, сочетающий в себе «несовместимое»: ООП и функциональное программирование (на самом деле F# — это oCaml с блекджеком и LINQом под .net). Есть аналог и для JVM — Scala. И совсем уж левый Nemerle. Так что готовимся к продолжению банкета со вкусной едой.
Появилось ещё до языков программирования, когда умный математик Алонзо Чёрч придумал лямбда-исчисление. Впервые было реализовано в Lisp (вторым по счёту ЯП после Фортрана). Заключается в низведении функций до уровня данных, а переменных до уровня констант. Идея здравая, поэтому настоящим программистам нравится, а заказчикам нет. А всё потому, что в функциональной парадигме нужно много думать, а потом написать десяток строчек, в то время как при императивном подходе можно написать 100 строчек вообще не думая — с тем же эффектом. Заказчик видит, что производительность (строчек в час) при использовании императивных языков выше, а значит, они лучше. Такие дела.
Функциональный код выглядит короче и наглядней во всех случаях, кроме тех, когда он выглядит длиннее и запутанней. А поддерживать и дебажить его — тот ещё ад, особенно если ошалевший небыдлокодер начинает необоснованно применять монады или функторы (а оно именно так и бывает в 95% случаев). Проблема в том, что большинство функциональщиков нихуя не владеют мат-базисом (λ-исчислением и теорией категорий), поэтому просто не понимают, зачем оно нужно, и используют по принципу «потому что могу» (порядка ради надо отметить, что императивщики дискретную математику вообще и теорию автоматов в частности знают не лучше, но для них это не критично).
Функциональное программирование окружает масса мифов. Перечитавшие Джоэла Спольски фонаты уверены, что любая программа на функциональном языке (даже если это домашка из первой главы SICP) автоматически масштабируется, летает и гарантирует, что его возьмут работать в Гугл. Конечно, функциональный код действительно неплохо масштабируются, но только если хорошенько попотеть. Даже общеизвестный LISP-овый факториал ни фига не пакетен, не масштабируем и тем более не поддерживает потоков. По сути, функциональная парадигма — это отличный инструмент для решения узкого круга задач, но уж никак не серебряная пуля, как рассказывают нам воннаби-небыдлокодеры. К примеру, попытка смоделировать систему с постоянно изменяющимся состоянием на каком-нибудь тру-функциональном Хаскеле превратится в монадный ад.
Поэтому функциональные языки всегда были в жопе, в серьёзном бизнесе не использовались и оставались уделом гиков, ибо деньги ими заработать нельзя. Так что функциональщикам только и остаётся, что после очередного высера на форуме: «вы все быдло с вашим ООП, смотрите как я получу бесконечную последовательность факториалов одной строчкой… как нахуй не надо?!», идти кодить на ненавистных Джавашарпах. Кушать-то хочется.
Парадигма, которая представляет программу как набор реакций на изменяющееся состояние. Ближайший аналог ИРЛ — условные рефлексы. Это позволяет здорово упростить представление: вместо одной обширной и необъятной блок-схемы, не умещающейся на листе ватмана формата A0, получается более удобный список небольших блок-схем, повешенных на события, что изрядно улучшает структуру обычной программы. Событийные языки поддерживают встроенный обработчик событий (к таковым относятся Delphi и C#), но при желании можно легко реализовать события на любом ООП языке с помощью паттерна , чем и пользуются разработчики на C++ и Java. Раньше событийная парадигма была золотым стандартом фреймвёрков (её используют такие мастодонты, как Delphi, WinForms и ранние версии QT), но с популяризацией паттернов и веяние сошло на нет.
Дело в том, что у событий есть одна маленькая проблема. Обработчики, висящие на событии, могут быть объявлены где угодно и кроме как при отладке нигде не видны. Причем они могут изменить состояние вызвавшего их объекта (традиция передавать sender как первый параметр тянется уже добрых четверть века) или вызывать следующие обработчики (ведь события это ни что иное, как реинкарнация оператора goto на более высоком уровне). В итоге простейший код можно превратить в эталонную лапшу. Что быдло и делает.

Бывает для взрослых и детей.
Суть в том, что вместо написания кода рисуешь то, что нужно:
А это учебные языки для маленьких детей, точнее, для родителей, желающих вырастить программера:
Ибо ваистену,
Какой язык учить?
Хочешь программировать на выразительном и мощном языке: Python
Нужно по-быстрому веб-сайт: PHP
Желаешь в тусовку зовущих себя «рок-звездами» программирования: Ruby
Реально нужно научиться программировать: C
Ищешь просветления: Scheme
Уйти в хандру: SQL
Потерять одну хромосому: Microsoft Visual Basic
Для получения постоянной, заурядной, но хорошо оплачиваемой работы по созданию финансовых приложений в офисной загородке под лампами дневного света: Java
Тоже самое, но с аббревиатурами и списком сертификатов в своей подписи: C#
Для получения волшебного, забытого в детстве, ощущения избавления от мании величия: Objective C
Но, однако,
Какой язык учить?
если реально нужно научиться программировать, но лень — си-шелл
если вы недоучили C и хотите искупить вину страданием — шелл
если у вас испорчено большинство кнопок клавиатуры — брейнфак
если вы снисходительно относитесь к низшим по званию — ада
если вам платят по строчкам кода — фортран
если ваша пенсия по старости недостаточна — кобол
если ваши программы записаны на магнитофонные кассеты — фокал
если вы не доверяете компилятору перемножить два числа — язык ассемблера
наоборот делать всегда если — форт
если вы ностальгируете по модему без коррекции ошибок — перл
если у вас чудовищная память, вмещающая две тысячи ключевых слов — PL/1
если вы хотите это, и то, и чтобы сразу — эрланг
если процедуры вам удобно держать в массивах — алгол-68
если всё это для вас детский лепет — хаскелл
Если вы вдруг нашли язык, с которым работаете, в разделах «быдлокодерские/небыдлокодерские языки», не спешите огорчаться или радоваться. Сами по себе вышеуказанные языки ничего не пишут и получающийся код является исключительно плодом вашего собственного моска и ручек. Другой вопрос, что некоторые языки проще для освоения и быстрого создания говна в промышленных масштабах, без значительных умственных и физических затрат, что делает их прекрасной средой для размножения быдлокодеров.
Для чего тогда сделано в этой статье вышеуказанное разделение? Just for lulz and holywars.
Также, закон Холивара применительно к языкам программирования звучит так:
Ненависть к языку программирования обратно пропорциональна знанию этого языка, знанию и пониманию задач, для решения которых он был создан и умению применять его на практике.
Язык сам по себе ничего не решает, главное то, что находится в верхней голове, брат.

 — дамп коллективного бессознательного /pr/, содержит провокационные суждения и радикальные мнения о разных языках и технологиях. Особенно интересен обзор языков от функциональщика.