История на програмните езици

Езиците за програмиране са изкуствени езици, които ни позволяват да даваме различни инструкции на машините и да споделяме алгоритмична информация. Tе имат голямо влияние върху обществото, тъй като са в основата на всеки информатично-технологически артефакт. Именно на тях дължим днешния бум на софтуерни технологии. Тази статия разглежда главните развития в историята на езиците за програмиране

Ранна история

През 1842 – 1843 година Ада Лъвлейс превежда статия на италианския математик Луиджи Менабрия, посветена на Аналитичната машина, замислена от Чарлз Бабидж. Към статията тя включва и свои бележки, които конкретизират в детайли метода за изчисляване на числата на Бернули с помощта на машината. За някои историци именно това е първата компютърна програма в света.

По-късно Херман Холерит осъзнава, че може да кодира информация върху перфокарти. Той достига до това заключение, след като наблюдава как влаковите кондуктори пресъздават физическите характеристики на собствениците на билети върху самите билети чрез позицията на продупчените дупки. След това Холерит кодира преброяването на населението през 1890 година на перфокарти.

През 1945 г. Джон фон Нойман, който работи за Института за авангардни науки, става автор на две важни концепции, които оказват значение за развитието на програмните езици за в бъдеще. Първата се нарича „shared-program technique“ (техника на споделените програми). Според Джон фон Нойман хардуерът на компютрите трябва да е прост и да не се налага да се реконструира за всяка нова програма. От това следва, че при по-сложни задачи ще е необходимо да се задават по-сложни инструкции.

Втората концепция е много важна за развитието на програмните езици. Джон фон Нойман я нарича Conditional control transfer (условно предаване на контрола). Тази идея поощрява използването на подпрограми или малки парчета код, които да могат да се извикват в нехронологичен ред. Освен това компютърният код трябва да има възможност да се разклонява с помощта на логически изрази като IF THEN, както и да се повтаря чрез FOR израза. Тази теория дава идеята за библиотеките – парчета код, които могат да се използват многократно.

Най-ранните компютърни кодове са имали строго специализирано приложение. В първите десетилетия на 20 век изчисленията са били базирани на десетичната бройна система. В края на краищата обаче хората осъзнават, че тази логика може да бъде успешно изразена не само с думи, но и с числа. Така например Алонсо Чърч успява успешно да изрази ламбда смятането чрез формули. Алтернативен процес на изчисление предлага Алън Тюринг в т.нар. машина на Тюринг, която е своеобразна абстракция на телетипите, използвани от телефонните компании. Машините на Тюринг полагат основите на компютърната архитектура на фон Нойман, при която програмите се съхраняват също като данните. За разлика от ламбда смятането, кодът на Тюринг не се оказва подходяща основа за програмните езици от по-високо ниво. Основното му приложение е в строгите анализи и в теорията на изчислителната сложност.

Подобно на много „начала“, трудно е да се посочи с точност кой точно е първият модерен програмен език. Още от самото начало езиците са силно ограничени от хардуера. Перфокартите позволяват 80 колони, но някои колони е трябвало да бъдат използвани за сортиращ номер на всяка карта. FORTRAN включва някои ключови думи от английския език, като например „IF“ (ако), „GOTO“ (отиди до) и „CONTINUE“ (продължи). Използването на магнитен барабан за компютърна памет означавало, че компютърните програми трябва да се съобразяват с въртенето му. Поради тази причина и програмите са силно зависими от хардуера.

За някои хора определянето на първия модерен език за програмиране зависи от това колко енергия и човешка четимост са необходими, за да се даде статут на „Език за програмиране“. Жакардовите станове, както и Диференциалната машина на Бабидж са разчитали на прости, ограничени „езици“ за описание на действията, които е трябвало да извършват. Дори перфорираните дупки на свитъка за механичното пиано, макар че не са предназначени за четене от човек, биха могли да се интерпретират като специфичен „програмен език“.

Първите езици за програмиране

През 40-те години на 20 век се създават първите наистина модерни компютри, захранвани от електричество. Ограничената скорост и памет принудила програмистите да пишат ръчно настроени програми с помощта на асемблерен език. В крайна сметка става ясно, че програмирането с помощта на асемблерен език изисква голямо интелектуално усилие и е можело да доведе до грешки.

Първият програмен език създаден така, че да задава инструкции на компютър, е написан през петдесетте. Един от първите езици за програмиране на високо ниво е Планкалкюл. Той е създаден от Конрад Цузе за немския компютър Z3 между 1943 и 1945 г.

Short code на Джон Моукли, предложен през 1949, е един от първите езици от високо ниво, проектирани за електронния компютър. За разлика от машинния код, в краткия код са представени математически изчисления в разбираема форма. Въпреки това програмата е трябвало да бъде преведена на машинен код при всяко стартиране, забавяйки по този начин процеса повече, отколкото при стартиране на еквивалентния машинен код.

През 1951 г. Грейс Хопър създава първия компилатор за Short code, наречен A-o. Компилаторът представлява програма която превръща всичките тези математически изрази в машинен код.

В началото на 50-те години на XX век в Университета на Манчестър Алик Глиние създава Автокод - програмен език, който използва компилатор, за да преобразува автоматично дадения език в машинен код. Първият код и първият компилатор са създадени през 1952 г. за компютъра Марк 1 в Университета на Манчестър – смята се, че това е първият компилиран програмен език от високо ниво.

Вторият автокод е създаден за компютъра Марк 1 от Р. А. Брукър през 1954 г. и е наречен Mark 1 Autocode. През 50-те Брукър, в сътрудничество с Университета на Манчестър, създава автокод и за Феранти Мъркюри. Версията за EDSAC 2 е била измислена през 1961 г. от Д. Ф. Хартли от Математическата лаборатория на Университета на Кеймбридж. Известна като EDSAC 2 Autocode, тя е стъпвала изцяло върху основите на Mercury Autocode. Освен това е била адаптирана за местните условия и е била известна със своята обектна кодова оптимизация и система за контролиран превод, които били напреднали за времето си. По същото време, но като отделна разработка, се появява Atlas Autocode за машината Atlas 1 в Университета на Манчестър.

FLOW-MATIC е друг ранен програмен код, създаден от Грейс Хопър в САЩ. Разработен е за UNIV в Ремингтън Ранд в периода 1955 – 1959 г.

Хопър открива, че клиентите, обработващи бизнес информация, не се чувстват комфортно с математическите символи. Затова през 1955 г. тя и нейният екип написват вариация за английския програмен език и създава прототип. Компилаторът FLOW-MATIC става обществено достояние през 1959 г. Той оказва съществено влияние върху дизайна на COBOL, тъй като по това време единствено той и неговият директен потомък AIMACO са били в реална употреба. В средата на 50-те години в IBM се създава и FORTRAN (FORmula TRANslating system) – език, чиято функция е била да подпомага научните изчисления. Той става първият широко използван програмен език от високо ниво с общо предназначение. Въпреки че е бил ограничен до ползването само на условни конструкции, като IF, DO и GOTO, FORTAN е бил доста напредничав за времето си. Основните типове данни в него намират място и в съвременните програмни езици. Например булевите и целочислените променливи, реални типове с плаваща запетая и реални типове с десетична точност.

През 1958 г. Джон Макарти създава езика LISP (LISt Processing), който намира приложение в областта на изкуствения интелект. Особеното при него е, че няма синтаксис, а единственият тип данни е бил списъкът (list). В средата на 60-те обаче LISP се сдобива и с други типове данни.

Списъкът в LISP представлява поредица от елементи, обградени със скоби. Самата програми са били изписвани като поредица от списъци. По този начин LISP е имал възможността да се модифицира сам и на практика да нараства от само себе си.

COBOL е създаден през 1959 г. с идеята да замести FORTAN. Основните му структури от данни са били числата и символните низове. Това е предоставяло по-голяма четимост. Интересно е да се отбележи, че COBOL има структура, подобна на есето. Освен това изразите в него са били доста сходни с английската граматика. Именно това прави COBOL лесен за научаване и използване.

Друг важен момент от средата на XX век, е пускането на ALGOL 60 (1960 г.) от комитета на Американските и европейски компютърни учени. Името му идва от Algorithmic Language заради алгоритмичните дефиниции на задачите. Той обединява много идеи, които са се обсъждали по онова време, и включва три ключови иновации в програмирането:

„загнездена“ блокова структура – кодът и свързаните с него декларации могат да бъдат групирани в блокове, без да се налага да се преобразуват в отделни и изрично наименувани процедури.
лексикален обхват – един блок може да разполага със свои собствени „частни“ променливи“, процедури и функции, които са невидими за кода, намиращ се извън този блок. Т.е. става дума за т.нар. „скриване на информация“.

Друга ключова иновация, свързана с ALGOL 60, е начинът, по който езикът е бил описван. За целта е използван метаезикът (формата) на Бекус-Наур. На практика почти всички езици, които ще се появят след това, ще използват вариация на тази форма, за да описват онази част от синтаксиса, която не е обвързана с конкретен контекст.

ALGOL 60 оказва особено голямо влияние в дизайна на следващите езици за програмиране, които бързо добиват голяма популярност.

Ключовите идеи на този език са прехвърлени и доразвити и в неговия наследник – ALGOL 68:

Синтаксисът и семантиката стават още по ортогонални – с анонимни рутини, система за рекурсивно изписване и т.н.
Не само онези части, които не са обвързани с конкретен контекст, но и целият езиков синтаксис и семантика са дефинирани формално посредством граматиката на Ван Вийнгардън – формализъм, създаден специално за тази цел.

По-непопулярните характеристики на ALGOL 68, като например едновременните и паралелните блокове, както и комплексната му система от синтактични преки пътища (и автоматични корекции) му печели репутацията на труден и не особено достъпен. Всъщност, Никлаус Вирт напуска дизайнерския екип, за да създаде доста по-семплия език Pascal.

По-важните езици, създадени в този период са:

1951 – Regional Assembly Language
1952 – Autocode
1954 – IPL (предшественик на LISP)
1955 – FLOW-MATIC (води до COBOL)
1957 – FORTRAN (първият компилатор)
1957 – COMTRAN (предшественик на COBOL)
1958 – LISP
1958 – ALGOL 58
1959 – FACT (предшественик на COBOL)
1959 – COBOL
1959 – RPG
1962 – APL
1962 – Simula
1962 – SNOBOL
1963 – CPL (предшественик на C)
1964 – BASIC
1964 – PL/I
1966 – JOSS
1967 – BCPL (предшественик на C)

Установяване на фундаменталните парадигми

Периодът от края на 60-те до края на 70-те години на 20 век се характеризира с разцвет на езиците за програмиране. Повечето от основните парадигми, които използваме днес, са създадени именно по това време.

Simula – това е първият обектно-ориентиран език. Създаден е през 1967 г. от Кристен Найгард и Оле-Йохан Дал. Използван е за изработването на симулационни програми, в които данните се представят посредством обекти. (1)
C – език, създаден от Деинс Ричи и Кен Томпсън в периода 1969 г. – 1973 г. Често се използва за системно програмиране. Той е междуплатформен, блоково структуриран, процедурен и императивен.
Smalltalk (средата на 70-те години на 20 век) – обектно-ориентиран език в пълния и най-чистия смисъл на този термин.
Prolog – създаден от 1972 г. от Ален Колмерое, Филип Ръсел и Робърт Ковалски. Това е първият език за логическо програмиране.
ML, създаден от Робърт Милнър през 1973 г. Проправя пътя на функционалното програмиране.

Всеки един от тези езици води до появата на цели семейства от „наследници“. Повечето модерни езици считат поне един от тях за свой предшественик.

60-те и 70-те се характеризират с началото на сериозен дебат, свързан с меродавността на „Структурното програмиране“. На практика това е писане на код без употребата на Goto. Спорът е тясно свързан с дизайна на езика – някои езици не включват Goto, което на практика налага структурното програмиране върху програмиста. Въпреки че, дебатът се е водил доста яростно по онова време, днес почти всички програмисти са на мнение, че дори и даден език да предлага Goto, употребата на тази команда е признак на лош стил (освен в много редки случаи). В резултат на това последното поколение езикови дизайнери разглеждат дебата за структурното програмиране като скучен и дори озадачаващ.

За да предоставят още по-високи скорости на компилиране, някои езици са били структурирани около т.нар. „one pass компилатори“. При тях второстепенните рутини трябва да се дефинират най-напред. Точно такъв е случаят и при Pascal – при него основната рутина (движещата функция) е във финалната част на кода.

Някои важни езици, създадени през този период:

1968 – Logo
1969 – B (предшественик на C)
1970 – Pascal
1970 – Forth
1972 – C
1972 – Smalltalk
1972 – Prolog
1973 – ML
1975 – Scheme
1978 – SQL

1980-те: консолидация, модули, производителност

През 1980-те години се наблюдава консолидация в императивните езици. Вместо да се създават нови парадигми, старите започват да се утвърждават и подобряват. C++ комбинира обектно-ориентираната парадигма със системната. Правителството на САЩ стандартизира Ada – структуриран, компилиращ се език за програмиране със статично определяне на типа подобен на Pascal. Той се е използвал от Министерството на отбраната.

В Япония, както и в останалите части на света, започват да се харчат огромни суми по т.нар. „пето поколение програмни езици“, които включват логически програмни конструкти. Обществото на функционалните програмисти започва да стандартизира ML и Lips. Проучванията върху функционалния език Miranda започват именно през това десетилетие.

Една важна нова тенденция в езиковия дизайн е все по-засиления фокус върху програмирането на многомащабни системи чрез употребата на модули – големи секции от организиран код. Modula, Ada и ML започват да включват модулни системи през 80-те. Модулните системи често се сравняват с т.нар. обобщено програмиране – подход, който позволява една стойност да бъде от различни типове, стига тя да отговаря на определени условия. Това свойство е известно още и като полиморфизъм.

В началото на развитието на компютърните технологии програмирането се е извършвало с машинен код. Първите опити за създаване на език за програмиране, различен от машинния, датират от 1949 година. Тогава е разработена система за кодиране на програми, наречена Short Code.

През 1950 година Майкъл Уилкс от Кеймбриджкия университет разработва така наречената Assembly System (транслираща система за език Асемблер). В асемблерските езици командите се записват с мнемонически кодове (кодови съкращения), които специална транслираща програма преобразува в машинни команди (двоичен код).

През втората половина на 1950-те се появяват първите програмни езици от високо ниво (трето поколение). При тях се разработва специален набор от езикови конструкции и правила за запис на инструкции от алгоритъма на дадена задача. Тъй като те се разработват като средство за описание на алгоритми, тези езици се наричат още алгоритмични или програмни езици. Те се отличават от машинно зависимите езици по по-високото структурно ниво на инструкциите и машинната независимост. Специални програми (компилатори, транслатори или интерпретатори) се използват за преобразуване на текста на програмите записани с алгоритмичните езици в двоичен код.

През 1954 г. започва работата по създаването на езика FORTRAN (FORmula TRANslation). През 1957 г. той е завършен и е реализиран като средство за създаване на програми за решаване на научно-технически задачи. Има различни версии: FORTRAN II (1958), FORTRAN III (1961), FORTRAN IV (1962), FORTRAN 77 (1966). FORTRAN получава много голямо разпространение и се използва и до днес. Езикът ALGOL е европейски вариант на алгоритмичен език от високо ниво. Той се разработва по поръчка на международен комитет, който се формира през 1958 година в Цюрих. През 1960 г. езикът е кръстен ALGOL 60.

През 1967 г. е създаден програмният език Бейсик, който е близък по идеи с езика FORTRAN, но с по-опростена структура. Програмите написани в Бейсик се изпълняват посредством интерпретатор – програма, която последователно преобразува командите в машинен код и ги изпълнява. Версията М-Бейсик е разработена от Уилям Гейтс и Пол Алън и с него е поставено началото на софтуерна компания Microsoft.

През 1968 г. Никлаус Вирт публикува описанието на своя език и го нарича на името на изобретателя на първото изчислително устройство – Паскал. През 1973 г. е разработен първият транслатор за този език, а малко по-късно е разработена програмната среда Turbo. Вследствие на лесния си синтаксис и добрите си инструменти за разработчици, езикът е бил особено подходящ за обучения и изучаване. Той е разполагал с дебъгър, среда за редактиране на кода и поддръжка на повечето микропроцесори, използвани в училищата.

PASCAL комбинира най-доброто от езиците по онова време. Той подобрява типа данни, наречени „указатели“, и добавя CASE-условната конструкция, позволяваща да се създадат инструкции, подобни на дървета:

Case expression OF
    Possible-expression-value-1:
        Statements to execute…
    Possible-expression-value-2:
        Statements to execute…
END

PASCAL също така спомага за разработката на динамичните променливи, които се създават в периода на изпълнението на програмата с помощта на NEW и DISPOSE командите. PASCAL обаче не използва динамични масиви или група от променливи. Именно това довежда до неговия край.

Програмният език Ada е създаден през 1979 г. Той е универсален език за програмиране с развити възможности за структуриране на данни. Намира широко приложение при програмиране на вградени системи в различни машини и оборудване.

Някои от по-важните езици в периода до 1990 г.:

1980 – C++
1983 – Ada
1984 – Common Lisp
1984 – MATLAB
1985 – Eiffel
1986 – Objective-C
1986 – Erlang
1987 – Perl
1988 – Tcl
1988 – Mathematica
1989 – FL (Backus)

90-те години на 20 век: Ерата на интернета

Силният растеж на интернет в средата на 90-те години е исторически скок в програмните езици. Чрез използване на коренно нови платформи за компютърни системи, интернет създаде възможности за усвояване на нови езици. Поради ранното интегриране на Netscape Navigator в уеб браузърите, програмният език JavaScript се превръща в един от най-използваните. Множество други скриптирани езици добиват широко приложение в разработването на персонализирани приложения за уеб сървъри, като PHP. През 1990 г. няма фундаментални новости в императивните езици. Започва ерата на разпространението на функционалните езици. Основната движеща философия в програмирането е била продуктивността. RAD е подход за разработка, при който приложения се създават визуално чрез сглобяване на готови компоненти посредством помощници и инструменти за автоматично генериране на голяма част от кода. В резултат приложенията се разработват много бързо, с малко ръчно писане на код и с намалени усилия от страна на програмиста. Такива са обектно ориентираните езици, като Object Pascal, Visual Basic и Java. Сред тях може би Java заслужава малко повече внимание.

В началото на 90-те години на 20 век интерактивната телевизия се е разглеждала като технология на бъдещето. Sun Microsystems решават, че този тип услуга се нуждае от специален, „преносим“ език. С други думи – такъв, който може да се използва на различни видове машини. Така се появява Java. През 1994 г., малко след провала на интерактивната телевизия, Java променя фокуса си и се насочва към мрежата. Година по-късно Netscape лицензира езика за използване с техния интернет браузър – Navigator. На Java започва да се гледа като на езика на бъдещето. Няколко компании създават приложения на Java. Нито едно от тях обаче не влиза в употреба.

Въпреки че Java си поставя доста амбициозни цели и е пример за добър програмен език, той така и не успява да реализира потенциала си. Има сериозни проблеми с оптимизацията – т.е. програмите, написани на него, се изпълняват доста бавно. Освен това Sun допълнителни затруднява разпространението му, като го въвлича в политически битки с Microsoft. За в бъдеще обаче Java обаче може и да се превърне в перфектния език за обучение, тъй като е наистина обектно-ориентиран и включва напреднали технологии. Например възможността да се използва в различни среди и наличието на „гарбидж колектор“ или инструмент за събиране на „отпадъци“.

Скриптовите езици са по-иновативни от RAD езиците. Това не е директно наследено от другите езици, развитието на синтаксиса и вграждането на повече функции. Повечето експерти са на мнение, че скриптираният език е по-продуктивен дори от RAD езиците. Скриптираните езици често се използват за малки проекти, но за големи поддържането и писането е по-трудно. Не на последно място, скриптираните програмни езици са едни от най-обещаващите във връзка с уеб браузърите.

Някои от по-важните езици развиващи се в този период:

1990 – Haskell
1991 – Python
1991 – Visual Basic
1993 – Ruby
1993 – Lua
1994 – CLOS
1995 – Ada 95
1995 – Java
1995 – Delphi (Object Pascal)
1995 – JavaScript
1995 – PHP
1996 – WebDNA
1997 – Rebol
1999 – D

Сегашни тенденции

Еволюцията на програмните езици продължава както в индустрията, така и в развиването на самите програмни езици. Програмирането преминава от класове към т.нар. аспектно-ориентирано програмиране (aspect-oriented programming). Насочва се към оптимизация на промените, като поставя във фокус трансформационните подходи. Ключовото понятие в новата парадигма е аспект и представлява нещо, подобно на клас, но с още по-високо ниво на абстракция. Аспектите могат да се отнасят до много класове. Те използват т.нар. „точки за вмъкване“ (insertion points) за да реализират в целия код регулярни действия, свързани например със сигурността на данните, с обработка на грешки и т.н. Идеята на аспектно-ориентираното програмиране може да се реализира в рамките на съществуващите езици.

По-важни тенденции през последните 15 години:

Функционалното програмиране започва да се използва все по-често. По този начин кодът става по-лесен за разбиране и паралелизиране (и на микро, и на макро нива).
Появяват се конструкти, поддържащи конкурентното и разпределителното програмиране.
Наличието на механизми, предоставящи по-висока сигурност и надеждност към езика: допълнителни статични проверки, зависими типове, контрол над информационния поток и т.н.
Алтернативни механизми за модулност, като делегати, аспекти и др. подобни.
Компонентно-ориентирана софтуерна разработка.
Появата на паралелни езици от типа на OpenCl.
Интерес към дистрибуцията и мобилността.
Интеграция за база данни, включително XML.
Отворен код като философия, включително GNU Compiler Collections и езици като Python, Ruby и Scala.
Първи стъпки в езиците за програмиране на квантови компютри.

По-важните езици от този период:

ActionScript, 2000 г. – обектно ориентиран език, създаден от Macromedia Inc. По синтаксис е близък до JavaScript. Използва се основно за уеб сайтове използващи платформата Adobe Flash Player и уеб сайтове с вградени SWF файлове.
C#, 2001 г. – обектно-ориентиран език за програмиране, разработен от Microsoft, като част от софтуерната платформа .NET. Първата версия на C# е разработена през 2001 г. и е пусната официално в употреба през 2002 г.
.NET Framework е да даде възможност за създаването на платформено независими приложения, т.е. на приложения, които могат да работят на различни операционни системи и хардуерни конфигурации. Като VB .NET, Visual Basic Version 4.0, реализиран през 1995 година да поддържа Microsoft's 32-битовата ОС. Mожеше да поддържа обектно-ориентирано програмиране под формата на клас модули (CLS файлове) и способността да генерира не само Windows изпълними, но и ActiveX DLLs (известни още като компоненти COM).
Groovy, 2003 г. – обектно ориентиран програмен език, който върви под Java платформата (JVM). Езикът е динамичен и има сходни черти с други скриптови езици, като Python, Ruby, Perl и Smalltalk. Езикът може да се използва като скриптов език за Java платформата. Groovy има вградена поддръжка на различни езици за описание на данни (markup languages) като XML и HTML, което се постига посредством вграден DOM синтаксис. Това позволява дефиницията и манипулирането на много типове хетерогенни данни със сходни характеристики, точен синтаксис и методология на програмирането.
Scala, 2003 г. е статично типизиран език, използва type inference механизъм, който сериозно намалява типовите декларации. Scala е чисто обектно-ориентиран език. Включва в себе си много елементи от функционалното програмиране:higher order functions,function objects,pattern matching,tail recursion.
F#, 2005 г. е език за програмиране за платформата .NET и Microsoft, който е използван за първи път във Visual Studio 2010. F# е обектно-ориентираното програмиране, но е първият пълноценен език за функционално програмиране (предназначен за технически изчисления, и за разработка на приложения за финансовите и научни среди) за .NET, и има за цел да постигне лесна интеграция с някои стари императивни езици като C + + и Java.
Go, 2005 г. е разработен от Google. Използва се за паралелни изчисления и ускоряване на работата на компютрите.Gоне е създаден с цел за разработка на софтуер.Go е статичен, компилиращ се език с автоматично освобождаване на ресурсите (garbage-collected). Синтаксиса му е близък до този на C. Обектно ориентиран език без класове. Има само един цикъл – for, конструкции if и Switch.
Dart, 2011 г. Създателят на Dart е Google. Идеята е този език да замени JavaScript. Dart е базиран на класовете и е предназначен за по-лесна разработка и поддръжка на уеб приложения. Основното предимство на езика е сходството му със синтаксиса на JavaScript. Dart позволява висока производителност за браузъри и среди, вариращи от мобилни устройства до сървъри.
Суифт, 2014 г. (на английски: Swift) е многопарадигмен компилируем програмен език, създаден от Apple за разработване на приложения за iOS и Mac. Swift е заместител на езика Objective-C. Но за разлика от Objective-C Swift не създава указатели (pointers).
Rust, 2015 г. Програмният език Rust е проект на Mozilla и е фокусиран върху безопасната работа с паметта и осигуряване на висок паралелизъм при изпълнение на програмите. Структурата на програмния език Rust напомня на C++, но съществено се различава по синтаксиса и семантиката. Rust автоматично управлява работата с паметта.

Използвана литература

Програмиране за .NET Framework – том 2, Светлин Наков и колектив, 2006 год

Външни препратки

Тази страница частично или изцяло представлява превод на страницата History of programming languages в Уикипедия на английски. Оригиналният текст, както и този превод, са защитени от Лиценза „Криейтив Комънс – Признание – Споделяне на споделеното“, а за съдържание, създадено преди юни 2009 година – от Лиценза за свободна документация на ГНУ. Прегледайте историята на редакциите на оригиналната страница, както и на преводната страница, за да видите списъка на съавторите.

ВАЖНО: Този шаблон се отнася единствено до авторските права върху съдържанието на статията. Добавянето му не отменя изискването да се посочват конкретни източници на твърденията, които да бъдат благонадеждни.