Преподаватель который помогает студентам и школьникам в учёбе.

История возникновения и развития языков для программирования Си (С++) и Java

Содержание:

Введение

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

В этой работе будет описано становление одного из самых крупных языков и пары выходцев из него.

1. Язык «С»

Язык «С» зародился в 1969 году, изначально планировавшийся как обновление предыдущего языка используемого на операционной системе Unix «B». Основное его развитие проходило до 1973 года. Также существенные изменения были внесены с 1977 по 1979 год, связанны они были в обновлением Unix, которое давало возможность переноса ОС на новые машины. Стандартизация языка проведена была в 80-х годах. Занимался этим комитет ANSI X3J11. Это дало возможность изучения языка гораздо большей аудитории и привело в достаточно высокой популярности языка, которая актуальна и сегодня.

Кен Томпсон, сотрудник компании Bell Telephone Laboratories, а так же группа его коллег работают над созданием операционной системы которая будет удовлетворять их запросам. Так появилась первая версия Unix написанная на ассемблере PDP-7, который все еще использовал бумажную ленту как способ ввода информации. Даже первая версия Unix уже была самодостаточной и позволяла писать и тестировать программы внутри себя. Вскоре после создания Unix, Дуг Макилрой сделал для него новый высокоуровневый системный язык TGM. Этот язык дал Томпсону идею что Unix нуждается в системном языке программирования. Так был придуман «В». Точнее говоря «В» не был придуман. «В» это модифицированный BCPL.

BCPL (Basic Combined Programming Language) создан Мартином Ричардсоном в 1967 году. Основная его цель – написание компиляторов для других языков. Структура языка дает возможность легкого переноса готовых компиляторов между машинами. Она разделена на две основные части: первая генерирует код в виртуальной машине, вторая переводит его для восприятия компьютером. Из-за того требуется переписывать лишь небольшую часть кода при переносе на новую технику.

Еще одна особенность языка, в нем есть только один тип данных: 16 битное слово (машинное слово). Она так же была основной проблемой при использовании на машинах где самый малый тип данных был байт и на машинах с большим размером слов (32 бита, 64 бита и т. д.). Несоответствие между ориентацией слов BCPL и байт-ориентированным оборудованием было рассмотрено несколькими способами. Один из них обеспечивал стандартные библиотечные процедуры для упаковки и распаковки слов в байтовые строки. Позже были добавлены две языковые функции: оператор выбора битового поля и оператор индексации байтов.

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

Основная причина модификации была ограниченная память машин, доступно было лишь 8 кбайт памяти, для BCPL этого было недостаточно. Даже после переписи «В» на компиляторе TGM это оставалось проблемой, после каждого обновления языка компилятор требовал все больше памяти. Но расширения языка давали возможность в будущем уменьшить размеры, путем изменения и добавления операторов. Так же были эксперименты с виртуальным компилятором «В»: программы внутри неё занимали меньше места (код и данные подкачивались внутри интерпретатора). Только это сильно замедляло работу программ, поэтому от этой идеи отказались. Томпсон сделал еще один шаг, добавив операторы ++ и – (увеличение и уменьшение). Они определяют, происходит ли изменение до или после значения операнда.

В системе Unix на PDP-7 только несколько вещей были написаны в B, кроме самого B, потому что машина была слишком маленькой и слишком медленной, чтобы делать больше, чем эксперимент. Переписывание операционной системы и утилит полностью в B тоже было слишком дорогим. Тем не менее, появились некоторые утилиты, написанные на B, включая раннюю версию DC-калькулятора с переменной точностью.

К 1970 году Томпсон и его команда смогли получить новый DEC PDP-11. Но процессор был доставлен на три месяца чем его диск. Для работы программ на B с шитым кодом, требовалось лишь написать фрагменты кода для операторов и простой ассемблер, который был закодирован на B. Ещё до какой-либо операционной системы, DC стала первой программой на PDP-11, которую можно было тестировать. В ожидание диска, Томпсон перекодировал ядро Unix и некоторые основные команды на языке ассемблера PDP-11.Из 24K байт памяти на самой ранней PDP-11 Unix использовалось 12K байт для операционной системы, небольшая часть для пользовательских программ, а остальное - как RAM-диск. Эта версия Unix была предназначена только для тестирования, а не для работы. Как только появился его диск, они быстро перешли к нему после перевода команд на языке ассемблера на язык PDP-11 и портирования тех, которые уже были в B.

Машины, на которых впервые использовались BCPL и B, имели язык с одним типом данных – ячейкой, которая совпадала с аппаратным машинным словам. Появление PDP-11 выявило несколько неудачных решений в семантической модели B. Его механизмы обработки символов, оставшиеся с небольшими изменениями от BCPL, были непродуктивны: использование библиотечных процедур для распространения строк в отдельные ячейки для последующей переупаковки или для доступа к отдельным символам. Так же исходный PDP-11 не предусматривал арифметику с плавающей запятой. Операции с плавающей точкой были добавлены в BCPL в компиляторах Multics и GCOS путем определения специальных операторов, но это работало только потому, что на соответствующих машинах одно слово было достаточно большим, чтобы содержать число с плавающей запятой, что не было возможно на 16-разрядном PDP-11. Еще построение B и BCPL создавало проблемы при работе с указателями: языковые правила, определяя указатель как индекс в массиве слов, принуждали указатели представляться индексами слов. Каждое обращение к указателю при исполнении генерировало масштабирование указателя в адрес байта, который ожидал процессор.

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

В 1971 с уже более мощными машинами «В» был расширен до «NB» (new B). Он добавил типы int и char, массивы из них и указатели на них. Семантика массивов оставалась такой же, как в B и BCPL: iarray и carray создают ячейки, указывающие на первую последовательность из 10 целых чисел и символов, ipointer и cpointer пропускают размер, чтобы память не выделялась автоматически. Значения в ячейках, привязанных к именам массива и указателя, были адресами машин, в байтах, в соответствующих областях хранения. Так косвенное использование указателя не имело накладных расходов во время выполнения, и указатель масштабировался от смещения от слова до байта. Но код для индексирования массива и вычислений указателя теперь зависит от типа массива и указателя: для вычисления iarray [i] или ipointer + i требуется масштабирование сложения i по размеру упомянутого объекта.

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

Это стало решающим шагом в цепочке между BCPL и C. Он устранил материализацию указателя в хранилище и вместо этого вызвал создание указателя, когда имя массива упоминается в выражении. Когда значения–массивы упоминаются в выражении, они конвертируются в указатели на первый из объектов, составляющих этот массив. Это позволило большинству существующих кодов на В продолжать работать, несмотря на смещение в семантике языка. Что еще более важно, новый язык сохранил последовательное и выполнимое (если не необычное) объяснение семантики массивов, открывая путь к более всеобъемлющей структуре типов.

Еще одно новшество, которое наиболее четко отличает C от В, - это более полная структура типа и особенно его выражение в синтаксисе деклараций. NB предложил базовые типы int и char, а также массивы из них и указатели на них, но никаких дополнительных способов составления. С учетом объекта любого типа должно быть возможно описать новый объект, который собирает несколько в массив, выводит его из функции или является указателем на него.

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

Основная схема компоновки типа C, была позаимствована у Algol 68. Основной идеей была структура типов, построенная на элементарных типах, объединениях в массивы, указателях и функциях. Понятия объединения и приведения типа тоже повлияли на то, что появилось позже.

После создания системы типов, связанного синтаксиса и компилятора для нового языка Томпсон почувствовал, что он заслужил новое имя; NB казался недостаточно отличительным. Он решил продолжить однобуквенный стиль и назвал его C.

К началу 1973 года основа современного была почти полной. Язык и компилятор были достаточно сильными для переписи ядра Unix для PDP-11 в C летом этого года. Также в течение этого периода компилятор был перенесен на похожие машины, потому что язык не мог жить изолированно, были разработаны варианты для современных библиотек. Например, был написан переносимый пакет ввода и вывода, позже переработанный в стандартную процедуру ввода и вывода C.

В 1973-1980 годах язык понемногу расширялся. В структура типов появились объединение, перечисление типы, беззнаковые и длинные типы, сами структуры стали похожи на объект-классы (не имеющими только обозначений для литералов). Не менее важные разработки проводились в его среде и сопутствующих технологиях. После написания ядра Unix на C началось перекодировка утилит и инструментов системы, атак же перенос интересных среди них на другие платформы. Основная сложность с распространением Unix-инструментов заключались не в взаимодействии языка C с новым оборудованием, а в адаптации к существующему программному обеспечению других операционных систем. Из за этого Стив Джонсон и начал работать над компилятором C, который мог легко переноситься на новые машины. В 1980-е годы использование C сильно распространилось. Компиляторы стали доступны практически для каждой архитектуры машин и операционных систем. В начале 80-х почти все компиляторы были основаны на pcc Джонсона, к середине уже стали появляться независимые.

К 1982 году было ясно, что C требуется формальная стандартизация. Лучшее приближение к стандарту, первое издание K&R, больше не описывает реальное использование языка; он не упоминал типа void или enum. Хотя он предвещал новый подход к структурам, только после того, как он был опубликован, поддержка языков назначала их, передавала их в функции и из них и связывала имена членов с категорией или объединением, содержащим их.

Первое издание K&R не было достаточно точным, и становится все более нецелесообразным рассматривать pcc как «ссылочный компилятор»; он не полностью воплощал язык, описанный K&R, не говоря уже о последующих расширениях. Наконец, начальное использование C в проектах, подпадающих под коммерческий и правительственный контракт, означало важность важности официального стандарта. Таким образом (по настоянию М. Д. Макилроя) ANSI учредил комитет X3J11 под руководством CBEMA летом 1983 года для создания стандарта C. X3J11 подготовил свой отчет в конце 1989 года, и впоследствии этот стандарт был принят ISO в соответствии с ISO / IEC 9899-1990.

В начале комитет X3J11 осторожно относился к языковым расширениям. Но они серьезно отнеслись к своей цели: «разработать ясный, целостный и однозначный стандарт для языка C, который кодирует общее существующее определение C и способствует переносимости пользовательских программ в средах языка C». Комитет понял, что простое обнародование стандарта не поможет. X3J11 представил только одно действительно важное изменение для самого языка: он включил типы формальных аргументов в сигнатуру типа функции, используя синтаксис, взятый из C ++.X3J11 также представила множество небольших дополнений и настроек, например, типы классификаторов const и volatile, а также несколько разные правила продвижения по типу.

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

Таким образом, основной язык C остался почти неизменным, и стандарт стал более качественной, тщательной кодификацией, чем новое изобретение. Более важные изменения произошли в среде языка: препроцессор и библиотека. Препроцессор выполняет макроподстановку, используя соглашения, отличные от остальной части языка. Его взаимодействие с компилятором не было хорошо описано, и X3J11 старался исправить ситуацию. Результат заметно лучше, чем объяснение в первом издании K&R; он является более полным, он обеспечивает операции, такие как объединение маркеров, ранее доступное только в результате аварий.

X3J11 знал, что полное и тщательное описание стандартной библиотеки C важно так же, как и работа над самим языком. Сам язык C не предусматривает ввода-вывода или любого другого взаимодействия с внешним миром и, следовательно, зависит от набора стандартных процедур. Во время публикации K&R C считался главным образом языком системного программирования Unix; хотя были представлены примеры библиотечных подпрограмм, предназначенные для легкой переносимости в другие операционные системы, явно понималось что сделаны для поддержки Unix. Таким образом, комитет X3J11 потратил большую часть своего времени на разработку и документирование набора библиотечных процедур, которые должны быть доступны во всех соответствующих реализациях.

По правилам процесса стандартов текущая деятельность X3J11 ограничивается интерпретацией существующего стандарта. Однако неофициальная группа, первоначально созванная Rex Jaeschke в качестве NCEG (Numerical C Extensions Group), была официально принята в качестве подгруппы X3J11.1, и они продолжают рассматривать расширения для C. Как следует из названия, многие из этих возможных расширений предназначены для создания языка более подходящим для массового использования: например, многомерные массивы, границы которых динамически определены, включают средства для работы с арифметикой IEEE и делают язык более эффективным на машинах с векторными или другими передовыми архитектурными особенностями. Не все возможные расширения являются особенно численными; они включают обозначение для строковых литералов.

После этого развитие языка не останавливалось. Были созданы еще несколько стандартов С. В 1990 году ISO приняло ISO/IEC 9899:1990 (С90), хотя изменения были небольшими.

В 1995 году ISO опубликовала расширение ISO / IEC 9899 / AMD1: 1995 или C95. Помимо исправления ошибок были внесены дальнейшие изменения в языковые возможности, такие как: улучшенная многобайтная и широкая поддержка символов в стандартной библиотеке, введением wchar.h и wctype.h, а также многобайтовые ввод-вывод, добавление диграфов на язык, спецификация стандартных макросов для альтернативной спецификации операторов, спецификация стандартного макроса __STDC_VERSION__.

В марте 2000 года ANSI приняла стандарт ISO / IEC 9899: 1999. Этот стандарт обычно называется C99. Некоторые примечательные дополнения к предыдущему стандарту включают: Новые встроенные типы данных: _Bool, long long , _Complex _Imaginary; Несколько новых функций основного языка, включая индексы статического массива, назначенные инициализаторы, сложные литералы, массивы переменной длины, гибкие члены массива, переменные макросы и ограничение ключевого слова; Несколько новых заголовков библиотек, включая stdint.h, tgmath.h, fenv.h, complex.h; Улучшенная совместимость с несколькими функциями C ++, включая встроенные функции, однострочные комментарии с //, объявлениями смешивания и кодом, а также универсальные имена символов в идентификаторах.

В апреле 2011 года был опубликован C11. Новый стандарт прошел свой окончательный проект обзора 10 октября 2011 года. ISO официально ратифицировало и опубликовало стандарт 8 декабря 2011 года в соответствии с ISO / IEC 9899: 2011. Основными изменениями в спецификации языка C11 были: Спецификация выравнивания (_Alignas, _Alignof, aligned_alloc, stdalign.h); Спецификатор _Noreturn и заголовочный файл stdnoreturn.h; Типовые выражения, _Generic ключевое слово; Поддержка многопоточности; Улучшенная поддержка Unicode на основе отчета C Unicode ISO / IEC TR 19769: 2004; Удаление функции get, замена на gets_s; Интерфейсы проверки границ, возможности анализа, анонимные структуры и союзы и прочее.

2. Язык «C++»

В 1979 году Бьёрн Страуструп, датский компьютерный ученый, начал работу над «C с классами», предшественником C ++. Мотивация для создания нового языка возникла из опыта Страуструпа в программировании для его докторской.

Первая версия этого симулятора была написана в Simula и работала на мэйнфрейме IBM 360/165 в компьютерном центре Кембриджского университета. Особенности Simula были почти идеальными для этой цели. Концепт классов позволил напрямую сопоставить концепции приложений с языковыми конструкциями что сделало код более удобно читаемым. Классы Simula могут выступать в качестве со-подпрограмм. Иерархии классов использовались для выражения вариантов применения уровня. Однако использование иерархий классов не было тяжелым. Концепция класса Simula рассматривалась как ключевое различие, воспринимаемый контраст между жесткостью Паскаля и гибкостью Simula была необходима для развития C ++.

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

Чтобы избежать завершения проекта, я повторно написал симулятор в BCPL и запустил его на экспериментальном компьютере CAP. Опыт кодирования и отладки симулятора в BCPL был ужасен. BCPL делает C похожим на язык очень высокого уровня и не обеспечивает абсолютно никакой проверки типа или поддержки во время выполнения. Полученный имитатор, однако, работал достаточно быстро и дал целое ряд полезных результатов, которые разъяснили мне многие вопросы и послужили основой для нескольких документов по вопросам операционной системы.

Смыслом C ++ было создание подходящего инструмента для таких проектов, как написания значительного симулятора, операционной системы и аналогичных задач системного программирования: Поддержка Simula для организации программы, то есть классы, с формой иерархии, формой поддержки параллелизма и сильной проверки системы типов на основе классов; Возможность создавать программы, которые выполнялись так же быстро, как программы BCPL, и были способны легко комбинировать отдельно скомпилированные единицы в программе; Обеспечение высокой переносимости реализаций. Самый важный аспект этих критерий являются то, что они слабо связаны с конкретными функциями языка программирования, они ограничивают решение проблем.

Работа над тем, что в конечном итоге стало C ++, началось с попытки анализа ядра UNIX чтобы определить, в какой степени он может быть распределен по локальной сети. Началась она в апреле 1979 года. Вскоре появились две проблемы: как проанализировать сетевой трафик, который будет получен из дистрибутива ядра, и как модулировать ядро. Оба потребовали способ выразить структуру модуля сложной системы и схемы связи модулей.

В октябре 1979 года был сделан предварительный процессор под названием Cpre, который добавил классы, похожие на Simula классы, в C и в марте 1980 года этот предварительный процессор был доработан до такой степени, что он поддерживал один реальный проект и несколько экспериментов. Несмотря на то, что поддержка параллелизма и симуляций в стиле Simula была основной целью C, язык не содержал примитивов для выражения параллелизма. У него была комбинация наследования иерархии классов и способность определять функции членов класса со специальными значения, распознанные препроцессором. Стили были решающими в этом - на языке должно быть выражено более одного понятия параллелизма. Существует множество приложений, для которых необходима поддержка параллелизма, но нет никакой доминирующей модели для поддержки параллелизма; когда необходимая поддержка должна предоставляться через библиотеку или специальное расширение, чтобы конкретная форма поддержки параллелизма не исключала других форм.

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

Раннее описание C с классами было опубликовано как технический отчет Bell Labs в апреле 1980, а затем в SIGPLAN Notices. В апреле 1982 года а затем более подробный технический отчет Bell Labs. Эти документы послужили хорошим примером, описав только те функции, которые были полностью реализованы и были использованы. C с классами был разработан, чтобы обеспечить лучшую организацию программ. Но улучшенная структура программы не была достигнута за счет расходов на время выполнения по сравнению с C. Цель была в том, чтобы соответствовать C по времени выполнения, компактности кода и данных. Но этого не получалось достигнуть. Это было неприемлемым, и накладные расходы были быстро устранены.

Еще одна серьезная проблема заключалась в том, чтобы избежать ограничений на домен, где C с классами мог быть использован. С ней смогли разобраться и C с классами мог делать тоже самое что и C. Это подразумевало, что в дополнение к сопоставлению C в эффективности, C с классами так же не мог устранить опасные функции C. Альтернативным способом обеспечения безопасности была вставка проверок во время выполнения всех небезопасных операций, но язык не может гарантировать такие проверки будут эффективны.

Успех C с классами был простым следствием реализации его проектной цели: он помогал организовать крупные классы программ, значительно лучше, чем C без потери эффективности во время выполнения и не требуя сильных изменений. Факторами, ограничивающими его успех, были частично ограниченный набор новых возможностей, предлагаемых на C, и частично препроцессорная технология, используемая для реализации C с классами. C с классами был важным шагом в правильном направлении, но шагом небольшим. В результате этого начался разрабатываться расширенный преемник C с классами.

Получившийся язык сначала по-прежнему назывался C с классами, но после ему дали имя C84. Причиной было то, что люди называли C с Классами «новый C» и просто C, а сам C назвали «старый C.». Но название C84 использовалось всего несколько месяцев. Поэтому было выбрано новое имя C++. Оно было коротким, хорошо интерпретируемым и не было лишь другой формой C.

В течение 1982-1984 годов цели для C ++ постепенно становились более амбициозными и более определенными. Разработчики инструментов в Bell Labs начали проявлять интерес к C ++, потому началась разработка совершенно новой реализации, которая станет интерфейсом компилятора C ++, Cfront

Первоначальная реализация Cfront была переносимой и дешевой. Именно в этом я и нуждались пользователи и могли себе позволить. Позже, было бы достаточно возможностей для AT&T и других, чтобы обеспечить лучшие инструменты для более специализированных сред. Инструменты, предназначенные прежде всего для промышленных пользователей, также не обязательно должны быть дешевыми, и, таким образом, они смогут оплачивать поддержку, необходимую для широкомасштабного использования языка.

Интерфейс компилятора Cfront для языка C84 был разработан и реализован между весной 1982 и летом 1983 года. Первый пользователь получил свою копию в июле 1983 года. Cfront был традиционным интерфейсом компилятора, выполняющим полную проверку синтаксиса и семантики языка, создавая внутреннее представление его ввода, анализируя и переставляя это представление, и, наконец, производящий выход, подходящий для некоторого генератора кода. Внутренним представлением был граф с одной таблицей символов для каждой области. Принцип состоит в том, чтобы читать исходный файл по одной глобальной декларации за раз и производить вывод только тогда, когда полная глобальная декларация была полностью проанализирована.

Организация Cfront довольно традиционная, за исключением, использования нескольких таблиц символов вместо одного. Cfront был первоначально написан на C с классами и вскоре переведен на C84, так что самый первый рабочий компилятор C ++ был выполнен на C ++. Даже первая версия Cfront использовала классы сильно, но не имела виртуальных функций, потому что они не были доступны в начале проекта.

Самый необычное (для своего времени) аспект Cfront заключался в том, что он сгенерировал C-код. Cfront сгенерировал C, потому что нужна была предельная переносимость для начальной реализации, и C был самым мобильным ассемблером. Впоследствии стратегия создания компилятора как генератора С стала довольно популярной, поэтому такие языки, как Ada, CLOS, Eiffel, Modula-3 и Smalltalk, были реализованы таким образом.

Компилятор С используется только как генератор кода. Любое сообщение об ошибке из компилятора C отражает ошибку в компиляторе C или Cfront, но не в исходном тексте C ++. Каждая синтаксическая и семантическая ошибка в принципе улавливается Cfront. Он был назван препроцессором, потому что он генерирует C, а для людей из сообщества C, это было доказательство того, что Cfront был простая программа - нечто вроде макропроцессора. Из-за этого люди ошибочно думали, что возможен перевод строки из C ++ на C, что символическая отладка на уровне C ++ невозможна при использовании Cfront, что код, сгенерированный Cfront, должен уступать коду созданный «реальными компиляторами», что C ++ не был «реальным языком» и т. д. Cfront является только интерфейсом компилятора и никогда не может использоваться для реального программирования сам по себе. Ему нужен драйвер для запуска исходного файла через препроцессор C, Cpp, а затем запуск вывода Cpp через Cfront и вывод Cfront через компилятор C.

С введением отдельного имени C ++ и написанием справочной материалов C ++ совместимость с C стала проблемой, имеющей большое значение и спорным вопросом. Кроме того, в конце 1983 года филиал Bell Labs, который разработал и поддерживал UNIX и выпускал компьютеры AT&T 3B, заинтересовался C ++ до такой степени, что они были готовы вкладывать ресурсы в разработку инструментов C ++. Такое развитие было необходимо для эволюции C ++ до языка, на котором корпорация могла бы основывать крупные проекты. Это также подразумевало нужду в управлении развития C ++.

Первым требованием было обеспечение 100% совместимости с C. Идеальность совместимости C вполне очевидна и разумна, но в реальности это не было так просто. АNSI C уже был к тому времени, но все еще были годы до стабильного определения. Естественно, что средний пользователь, который хотел C-совместимость, настаивал на том, что C ++ должен быть совместим с местным диалектом C. Позже, после многих технических проблем и большого недовольства пользователей, вложенные классы классов были повторно введены в C ++ в 1989 году, комитет ANSI C принял немного более слабую версию правил и обозначений C ++ в этой точке и объявил применения, которые не соответствуют устаревшим правилам C ++. Было принято правило C, что глобальные имена по умолчанию доступны из других единиц компиляции. Там просто не было поддержки более строгого правила C ++. C ++, как и C, не имеет эффективного механизма выражения модульности над уровнем класса и файла.

Осенью 1983 года была начата работа над книгой «С ++ Язык программирования». Завершение книги заняло девять месяцев. В предисловии упоминаются люди, которые к тому времени внесли наибольший вклад в C ++: Том Каргилл, Джим Коплиен, Стю Фельдман, Сэнди Фрейзер, Стив Джонсон, Брайан Керниган, Барт Локанти, Дуг Макилрой, Деннис Ритчи, Ларри Рослер, Джерри Шварц и Джон Шопиро. «C ++ был разработан в первую очередь так, что автору и его друзьям не нужно было программировать на ассемблере, C или различных современных языках высокого уровня. Его основная цель - сделать написанные хорошие программы более легкими и приятными для отдельного программиста». «Язык программирования C ++» - это определение C ++ и введение в C ++ для неизвестного количества программистов, а также методы и организация его представления (заимствованные с признаниями, если не всегда достаточные навыки от «языка программирования C») становятся основой для почти смущающего количества статей и книг. Это было написано с явной решимостью не проповедовать какой-либо конкретной техники программирования.

Когда-то в 1988 году стало ясно, что C ++ в конечном итоге придется стандартизировать. В настоящее время существует несколько независимых реализаций, которые используются или создаются, и явно необходимо приложить усилия для написания более точного и всеобъемлющего определения языка, а также для широкого признания этого определения. Сначала формальная стандартизация не рассматривалась как вариант. Однако создание улучшенного справочного руководства не было чем-то, что мог сделать один человек. Необходимы вход и обратная связь от сообщества C ++. Примерно в то же время часть AT & T, которая продавала C ++, хотела создать новое и улучшенное справочное руководство по C ++ и дала Маргарет Эллис задачу написать его. Было разумно объединить усилия и подготовить единое справочное пособие, выходящее извне. Таким образом, «Аннотированное справочное руководство по C ++» было написано, чтобы обеспечить прочную основу для дальнейшей эволюции C ++ и чтобы служить отправной точкой для формальной стандартизации C ++. ''

В 2003 году вышел стандарт C ++ 03. Он был определен ISO и IEC в стандарте ISO / IEC 14882: 2003.

C ++ 03 был в основном выпуском исправления ошибок для разработчиков, чтобы обеспечить большую согласованность и переносимость. Эта ревизия адресовала 92 отчета о дефектах языка, 125 отчетов об ошибках библиотеки и включила только одну новую языковую функцию: инициализация значения. Среди более примечательных отчетов о дефектах, адресованных C ++ 03, был отчет о дефекте библиотеки 69, разрешение которого добавило требование сохранения элементов в векторе. Это кодирует общее ожидание того, что объект std :: vector C ++ использует макет памяти, подобный массиву. Хотя большинство реализаций удовлетворяли этому ожиданию, C ++ 98 не требовалось.

12 августа 2011 года вышел еще один стандарт - C ++ 11. Он был одобрен ISO и был опубликован как ISO/IEC 14882: 2011 в сентябре 2011 года. Хотя ранее он был назван C ++1x, потому что должен был быть опубликован до 2010 года.

Хотя одна из целей дизайна заключалась в том, чтобы предпочесть изменения в библиотеках по сравнению с основным языком, C ++ 11 делал несколько дополнений к основному языку. Области основного языка, которые были значительно улучшены, включают: поддержку многопоточности, общую поддержку программирования, равномерную инициализацию и производительность. Значительные изменения были внесены в стандартную библиотеку C ++, включающую большинство библиотек C ++ Technical Report 1 (TR1), за исключением библиотеки математических специальных функций.

В 2014 году вышел C ++ 14 - версия стандарта ISO / IEC 14882. Он изначально был небольшим расширением для C ++ 11, включая исправления ошибок и небольшие улучшения. Его одобрение было объявлено 18 августа 2014 года. C ++ 14 был выпущен 15 декабря 2014 года.

До того, как Комитет по стандартам С ++ установил трехлетний цикл выпуска, дата выпуска C ++ 17 была неопределенной. Спецификация C ++ 17 достигла стадии проекта международного стандарта (DIS) в марте 2017 года. Этот DIS был единогласно одобрен, только с редакционными комментариями, а окончательный стандарт был опубликован в декабре 2017 года. Немногие изменения были внесены в стандартную библиотеку шаблонов C ++, хотя некоторые алгоритмы в заголовке <algorithm> получили поддержку для явного распараллеливания и некоторые синтаксические улучшения.

3. Платформа и язык Java

Платформа и язык Java начали разрабатываться в качестве внутреннего проекта Sun Microsystems в декабре 1990 года, как альтернатива языкам программирования C ++ / C. Инженер Патрик Нотон все больше расстраивался состоянием интерфейсов прикладного программирования (API) Sun и C ++, а также с тем, как проект NeWS обрабатывался организацией. Он предусматривал создание небольшой команды, которая могла бы работать автономно без бюрократии, которая затормозила другие проекты Sun. Макнили переслал сообщение другим важным людям в Sun, и начался проект Stealth.

Проект Stealth вскоре был переименован в Green, а Джеймс Гослинг и Майк Шеридан присоединились к Нотону вместе с другими инженерами. Они стремились разработать новую технологию для программирования интеллектуальных устройств следующего поколения.

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

Билл Джой представил новый язык, объединяющий Mesa и C. В статье под названием «Дополнительно» он предложил Sun, чтобы ее инженеры должны были создать объектно-ориентированную среду на основе C++. Первоначально Гослинг пытался модифицировать и расширять C++ (предлагаемую разработку, которую он назвал «C ++ ++ -»), но вскоре отказался от этого в пользу создания нового языка, который он назвал Oak.

К лету 1992 года команда могла продемонстрировать часть новой платформы, включая Green OS, язык Oak, библиотеки и аппаратное обеспечение. Их первая демонстрация, 3 сентября 1992 года, была сосредоточена на создании устройства персонального цифрового помощника (PDA) Star7 с графическим интерфейсом и интеллектуальным агентом под названием «Duke», помогающего пользователю. В ноябре того же года Green Project был выделен, чтобы стать Firstperson, дочерней компанией Sun Microsystems, и команда переехала в Пало-Альто, штат Калифорния. Команда Firstperson заинтересовалась созданием высокоинтерактивных устройств, и когда Time Warner выпустил запрос на предложение (RFP) для телевизионной приставки, Firstperson изменил свою цель и ответил предложением о платформе телеприставки. Однако кабельная индустрия считала, что их платформа слишком сильно контролирует пользователя, поэтому Firstperson потерял свою ставку в SGI. Дополнительную сделку с компанией 3DO для телеприставки также не удалось реализовать. Не в состоянии вызвать интерес в телевизионной индустрии, компания была возвращена в Sun.

В июне и июле 1994 года - после трех дней мозгового штурма с Джоном Гейге (директором по науке для Sun), Гослингом, Джоем, Нотоном, Уэйном Розингом и Эриком Шмидт - команда перенацелила платформу для Всемирной паутины. Они поняли, что с появлением графических веб-браузеров, таких как Mosaic, интернет может перерасти в ту же самую интерактивную среду, которую они предусмотрели для кабельного телевидения. В качестве прототипа Naughton написал небольшой браузер, WebRunner, переименованный в HotJava в 1995 году.

В 1994 году Sun переименовала язык Oak на Java, так как Oak уже был занят. Хотя Java 1.0a стала доступна для скачивания в 1994 году, первый публичный выпуск Java 1.0a2 с браузером HotJava, появился 23 мая 1995 года, анонсированный на конференции SunWorld. Марк Андреессен, исполнительный вице-президент Netscape Communications Corporation, неожиданно объявил, что браузеры Netscape будут включать поддержку Java. 9 января 1996 года Sun Microsystems сформировали группу JavaSoft для разработки технологии.

В то время как Java-апплеты для веб-браузеров больше не являются наиболее популярным использованием Java (с ним, например, более используемым сервером) или самым популярным способом запуска кода на стороне клиента (использование JavaScript стало более популярным), это все еще возможно запустить Java (или другие JVM-языки, такие как Kotlin) в веб-браузерах, даже после того, как поддержка JVM была удалена из них, используя, например, TeaVM.

Язык Java претерпел несколько изменений после выпуска Java Development Kit (JDK) 1.0 от 23 января 1996 года, а также множество дополнений r классам и пакетам к стандартной библиотеки. Начиная с J2SE 1.4, Java Community Process (JCP) управляет эволюцией Java-языка. JCP использует запросы спецификации Java (JSR) для предложения и указания дополнений и изменений на платформе Java. Спецификация языка Java (JLS) используют для спецификации языка; изменения в JLS управляются в JSR 901.

19 февраля 1997 года Sun выпустила JDK 1.1. Основные дополнения включали в себя обширное обновление модели событий AWT, добавление внутренних классов на язык JavaBeans и JDBC.

J2SE 1.2 (8 декабря 1998 г.) - Codename Playground. Этот и последующие выпуски через J2SE 5.0 были переименованы в Java 2, а имя версии J2SE (Java 2 Platform, Standard Edition) заменило JDK, чтобы отличить базовую платформу от J2EE (Java 2 Platform, Enterprise Edition) и J2ME (платформа Java 2, Micro Edition). Основные дополнения включали отражение, структуру коллекций, Java IDL (реализация языка описания интерфейса для взаимодействия CORBA) и интеграцию графического API Swing в основные классы. Был выпущен Java-модуль, а JVM от Sun был оснащен компилятором JIT в первый раз.

J2SE 1.3 (8 мая 2000 г.) - Codename Kestrel. Заметные изменения включали в себя объединение HotSpot JVM (JVM HotSpot была впервые выпущена в апреле 1999 года для J2SE 1.2 JVM), JavaSound, Java Naming and Directory Interface (JNDI) и Java Debugger Architecture (JPDA).

J2SE 1.4 (6 февраля 2002 г.) - Codename Merlin. Это стало первым выпуском платформы Java, разработанной в рамках Java Community Process как JSR 59. Основные изменения включали регулярные выражения, моделируемые после Perl, цепочку исключений, интегрированный синтаксический анализатор XML и XSLT-процессор (JAXP) и Java Web Start.

J2SE 5.0 (30 сентября 2004 г.) - Codename Tiger. Первоначально он был пронумерован 1,5, который по-прежнему используется как внутренний номер версии. Разработанный под JSR 176, Tiger добавил несколько важных новых языковых функций, в том числе для каждого цикла, generics, autoboxing и var-args.

Java SE 6 (11 декабря 2006 г.) - Codename Mustang. Он был связан с менеджером базы данных и облегчает использование языков сценариев с помощью JVM (например, JavaScript с использованием Mozilla's Rhino engine). Начиная с этой версии, Sun заменила имя «J2SE» на Java SE и сбросила «.0» из номера версии. Другие существенные изменения включают поддержку подключаемых аннотаций (JSR 269), много улучшений графического интерфейса пользователя, включая собственные усовершенствования пользовательского интерфейса для поддержки внешнего вида Windows Vista и улучшения интерфейса Java Platform Debugger Architecture (JPDA) и JVM Tool Interface для лучшего мониторинга и поиск проблемы.

Java SE 7 (28 июля 2011 г.) - Codename Dolphin. Эта версия разработана под JSR 336. Он добавил много небольших изменений языка, включая строки в коммутаторе, try-with-resources и тип вывода для создания общего экземпляра. JVM был расширен с поддержкой динамических языков, в то время как библиотека классов была расширена среди других с помощью структуры join / fork, улучшенной библиотеки ввода-вывода файлов и поддержки новых сетевых протоколов, таких как SCTP. Обновление Java 7 76 было выпущено в январе 2015 года.

Java SE 8 (18 марта 2014 г.). Значительные изменения включают поддержку уровня лямбда-выражений (закрытий) на уровне языка и методы по умолчанию, среду исполнения JavaScript проекта Nashorn, новый API дат и времени, созданный Joda Time, и удаление PermGen. Эта версия официально не поддерживается на платформе Windows XP. Однако из-за конца жизненного цикла Java 7 это рекомендуемая версия для пользователей XP. Ранее для Windows XP SP3 был описан только неофициальный метод ручной установки. Это относится к JDK8, платформе разработки для Java, которая также включает полностью функционирующую среду выполнения Java. Java 8 поддерживается в Windows Server 2008 R2 с пакетом обновления 1 (SP1), Windows Vista SP2 и Windows 7 с пакетом обновления 1 (SP1), Ubuntu 12.04 LTS и выше (и некоторые другие ОС).

Java SE 9 и 10 имели более высокие требования к системе, то есть Windows 7 или Server 2012 (и минимальный сертификат веб-браузера повышался до Internet Explorer 11 или других веб-браузеров), а Oracle потеряла 32-разрядную совместимость для всех платформ, то есть только Oracle «64 -битные виртуальные машины Java (JVM) сертифицированы».

Java SE 11 был выпущен в сентябре 2018 года, первый выпуск LTS, так как была принята модель быстрого выпуска, начиная с версии 9. Впервые OpenJDK 11 представляет собой полный исходный код платформы Java под лицензией GNU General Public License, а Oracle все еще с двойным лицензированием с дополнительной лицензией на собственность, нет никаких различий кода или модулей, уникальных для лицензированной версии. Возможности Java 11 включают в себя две новые реализации сборщика мусора, Flight Recorder для отладки глубоких проблем, новый HTTP-клиент, включая поддержку WebSocket.

В дополнение к языковым изменениям значительные изменения были внесены в библиотеку классов Java на протяжении многих лет, что выросла с нескольких сотен классов в JDK 1.0 до более чем трех тысяч в J2SE 5.0. Все новые API, такие как Swing и Java 2D, развились, и многие из оригинальных классов и методов JDK 1.0 устарели.

Заключение

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

Список литературы

Bjarne Stroustrup ‘A History of C++: 1979-1991’ AT&T Bell Laboratories Murray Hill
Dennis M. Ritchie ‘The Development of the C Language’ Bell Labs/Lucent Technologies Murray Hill
B. Anderson, `Type syntax in the language C: an object lesson in syntactic innovation,' SIGPLAN Notices 15 (3), March, 1980, pp. 21-27.
J. R. Bell, `Threaded Code,' C. ACM 16 (6), pp. 370-372.
F. J. Corbato, M. Merwin-Dagget, R. C. Daley, `An Experimental Time-sharing System,' AFIPS Conf. Proc. SJCC, 1962, pp. 335-344.
S. C. Johnson and B. W. Kernighan, `The Programming Language B,' Comp. Sci. Tech. Report #8, AT&T Bell Laboratories (January 1973).
B. W. Kernighan and D. M. Ritchie, The C Programming Language, Prentice-Hall: Englewood Cliffs, NJ, 1978. Second edition, 1988.
T. MacDonald, `Arrays of variable length,' J. C Lang. Trans 1 (3), Dec. 1989, pp. 215-233.
R. M. McClure, `TMG—A Syntax Directed Compiler,' Proc. 20th ACM National Conf. (1965), pp. 262-274.
M. D. McIlroy, `Macro Instruction Extensions of Compiler Languages,' C. ACM 3 (4), pp. 214-220.
M. Richards and C. Whitbey-Strevens, BCPL: The Language and its Compiler, Cambridge Univ. Press: Cambridge, 1979.
D. M. Ritchie, `The Evolution of the UNIX Time-sharing System,' AT&T Bell Labs. Tech. J. 63 (8) (part 2), Oct. 1984.
D. M. Ritchie, `Variable-size arrays in C,' J. C Lang. Trans. 2 (2), Sept. 1990, pp. 81-86.
1. Snyder, A Portable Compiler for the Language C, MIT: Cambridge, Mass., 1974.
J. E. Stoy and C. Strachey, `OS6—An experimental operating system for a small computer. Part I: General principles and structure,' Comp J. 15, (Aug. 1972), pp. 117-124.
B. Stroustrup, The C++ Programming Language, Addison-Wesley: Reading, Mass., 1986. Second edition, 1991.
A. van Wijngaarden, B. J. Mailloux, J. E. Peck, C. H. Koster, M. Sintzoff, C. Lindsey, L. G. Meertens, R. G. Fisker, `Revised report on the algorithmic language Algol 68,' Acta Informatica 5, pp. 1-236.
James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 2: Window Toolkit and Applets, Addison-Wesley, 1996
James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 1: Core Packages, Addison-Wesley, 1996
James Gosling, Henry McGilton, The Java language Environment: A white paper, Sun Microsystems, 1996
James Gosling, David S. H. Rosenthal, Michelle J. Arden, The NeWS Book : An Introduction to the Network/Extensible Window System (Sun Technical Reference Library), Springer, 1989