Скомпилированные и интерпретируемые языки

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

Интерпретируемый язык - это язык, в котором инструкции не выполняются напрямую целевой машиной, а вместо этого читаются и выполняются какой-либо другой программой (которая обычно написана на языке собственной машины). Например, та же операция «+» будет распознаваться интерпретатором во время выполнения, который затем вызовет свою собственную функцию «add (a, b)» с соответствующими аргументами, которая затем выполнит инструкцию машинного кода «ADD». .

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

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

• Повышение производительности за счет прямого использования собственного кода целевой машины
• Возможность применить довольно мощные оптимизации на этапе компиляции

И вот преимущества интерпретируемых языков:

• Проще реализовать (писать хорошие компиляторы очень сложно !!)
• Нет необходимости запускать этап компиляции: можно выполнять код прямо «на лету»
• Может быть удобнее для динамических языков

Обратите внимание, что современные методы, такие как компиляция байт-кода, добавляют некоторую дополнительную сложность - здесь происходит то, что компилятор нацелен на «виртуальную машину», которая не совпадает с базовым оборудованием. Эти инструкции виртуальной машины могут быть затем снова скомпилированы на более позднем этапе для получения собственного кода (например, как это делает JIT-компилятор Java JVM).

Сам язык не компилируется и не интерпретируется, только конкретная реализация языка. Java - прекрасный тому пример. Существует платформа на основе байт-кода (JVM), собственный компилятор (gcj) и интерпретатор для расширенного набора Java (bsh). Так что же такое Java сейчас? Скомпилирован в байт-код, скомпилирован в собственном коде или интерпретирован?

Другие языки, которые компилируются и интерпретируются, - это Scala, Haskell или Ocaml. У каждого из этих языков есть интерактивный интерпретатор, а также компилятор байтового или машинного кода.

Так что в целом разделение языков на «скомпилированные» и «интерпретируемые» не имеет особого смысла.

Начните думать с точки зрения: взрыва из прошлого

Давным-давно жили вычислительные интерпретаторы и компиляторы. Возникла всякая суета по поводу достоинств одного перед другим. Общее мнение в то время было примерно таким:

• Интерпретатор: Быстро разрабатывать (редактировать и запускать). Медленное выполнение, потому что каждый оператор должен был интерпретироваться в машинный код каждый раз, когда он выполнялся (подумайте, что это означало для цикла, выполняемого тысячи раз).
• Компилятор: медленно разрабатывать (редактировать, компилировать, связывать и запускать. Этапы компиляции / компоновки могут занять много времени). Быстро выполнить. Вся программа была уже в машинном коде.

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

Сегодня ландшафт изменился до такой степени, что составленное / интерпретируемое различие в значительной степени неуместно. Многие скомпилированные языки вызывают службы времени выполнения, которые не полностью основаны на машинном коде. Кроме того, большинство интерпретируемых языков перед выполнением «компилируются» в байт-код. Интерпретаторы байт-кода могут быть очень эффективными и конкурировать с кодом, сгенерированным компилятором, с точки зрения скорости выполнения.

Классическое отличие состоит в том, что компиляторы генерируют собственный машинный код, интерпретаторы читают исходный код и генерируют машинный код на лету, используя какую-то систему времени выполнения. Сегодня осталось очень мало классических интерпретаторов - почти все они компилируются в байт-код (или какое-то другое полукомпилированное состояние), который затем запускается на виртуальной «машине».

Крайний и простой случаи:

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

• Интерпретатор представит пользователю приглашение в цикле, где он может вводить операторы или код, и после нажатия RUN или эквивалентного интерпретатор будет исследовать, сканировать, анализировать и интерпретировать каждую строку до тех пор, пока программа не дойдет до точки остановки или ошибка. Поскольку каждая строка обрабатывается сама по себе, и интерпретатор ничего не «узнает» из того, что видел строку раньше, усилия по преобразованию понятного человеку языка в машинные инструкции возникают каждый раз для каждой строки, так что это очень медленно. С другой стороны, пользователь может проверять свою программу и иным образом взаимодействовать с ней различными способами: изменять переменные, изменять код, работать в режимах трассировки или отладки ...

Разобравшись с этим, позвольте мне объяснить, что жизнь уже не так проста. Например,

• Многие интерпретаторы предварительно компилируют предоставленный им код, поэтому шаг перевода не нужно повторять снова и снова.
• Некоторые компиляторы компилируются не в машинные инструкции, специфичные для процессора, а в байт-код, своего рода искусственный машинный код для фиктивной машины. Это делает скомпилированную программу немного более переносимой, но требует интерпретатора байт-кода в каждой целевой системе.
• Интерпретаторы байт-кода (я здесь смотрю на Java) в последнее время склонны повторно компилировать байт-код, который они получают для ЦП целевой секции непосредственно перед выполнением (так называемый JIT). Чтобы сэкономить время, это часто делается только для часто запускаемого кода (горячие точки).
• Некоторые системы, которые выглядят и действуют как интерпретаторы (например, Clojure), немедленно компилируют любой код, который они получают, но предоставляют интерактивный доступ к среде программы. Это в основном удобство интерпретаторов со скоростью двоичной компиляции.
• Некоторые компиляторы на самом деле не компилируются, они просто предварительно переваривают и сжимают код. Некоторое время назад я слышал, как работает Perl. Так что иногда компилятор просто выполняет небольшую работу, и большая часть ее остается интерпретацией.

В конце концов, в наши дни интерпретация и компиляция - это компромисс, когда время, потраченное (однажды) на компиляцию, часто вознаграждается лучшей производительностью во время выполнения, но среда интерпретации дает больше возможностей для взаимодействия. Компиляция и интерпретация - это в основном вопрос того, как работа по «пониманию» программы распределяется между различными процессами, и в наши дни граница немного размыта, поскольку языки и продукты пытаются предложить лучшее из обоих миров.

С http://www.quora.com/What-is-the-difference-between-compiled-and-interpreted-programming-languages

Нет никакой разницы, потому что «скомпилированный язык программирования» и «интерпретируемый язык программирования» не имеют смысла. Любой язык программирования, я имею в виду любой, может быть интерпретирован или скомпилирован. Таким образом, интерпретация и компиляция - это методы реализации, а не атрибуты языков.

Интерпретация - это метод, с помощью которого другая программа, интерпретатор, выполняет операции от имени интерпретируемой программы, чтобы запустить ее. Если вы можете представить, как читаете программу и делаете то, что в ней говорится, шаг за шагом, скажем, на листе бумаги, то это то же самое, что и интерпретатор. Распространенной причиной интерпретации программы является то, что интерпретаторы относительно легко написать. Другая причина заключается в том, что интерпретатор может отслеживать, что программа пытается делать во время работы, чтобы обеспечить соблюдение политики, скажем, для безопасности.

Компиляция - это метод, с помощью которого программа, написанная на одном языке («исходный язык»), переводится в программу на другом языке («объектный язык»), что, будем надеяться, означает то же самое, что и исходная программа. При переводе компилятор часто также пытается преобразовать программу таким образом, чтобы ускорить выполнение объектной программы (без изменения ее смысла!). Распространенная причина для компиляции программы состоит в том, что есть хороший способ быстро запускать программы на объектном языке без дополнительных затрат на интерпретацию исходного языка.

Вы, возможно, догадались, основываясь на приведенных выше определениях, что эти два метода реализации не исключают друг друга и могут даже дополнять друг друга. Традиционно объектным языком компилятора был машинный код или что-то подобное, что относится к любому количеству языков программирования, понятных конкретным процессорам компьютера. Тогда машинный код будет работать «на металле» (хотя можно увидеть, если присмотреться, что «металл» работает во многом как интерпретатор). Сегодня, однако, очень распространено использование компилятора для генерации объектного кода, предназначенного для интерпретации - например, именно так работала Java (а иногда и продолжает работать). Существуют компиляторы, которые переводят другие языки на JavaScript, который затем часто запускается в веб-браузере, который может интерпретировать JavaScript или скомпилировать его как виртуальную машину или собственный код. У нас также есть интерпретаторы машинного кода, которые можно использовать для эмуляции одного типа оборудования на другом. Или можно использовать компилятор для генерации объектного кода, который затем является исходным кодом для другого компилятора, который может даже скомпилировать код в памяти как раз вовремя для его запуска, что в свою очередь. . . вы поняли. Есть много способов объединить эти концепции.

Самым большим преимуществом интерпретируемого исходного кода перед скомпилированным исходным кодом является ПОРТАТИВНОСТЬ.

Если ваш исходный код скомпилирован, вам необходимо скомпилировать другой исполняемый файл для каждого типа процессора и / или платформы, на которой вы хотите, чтобы ваша программа работала (например, один для Windows x86, один для Windows x64, один для Linux x64 и т. Д. на). Кроме того, если ваш код не полностью соответствует стандартам и не использует какие-либо функции / библиотеки, специфичные для платформы, вам действительно нужно будет написать и поддерживать несколько баз кода!

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

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

Компилятор и интерпретатор выполняют одну и ту же работу: переводят язык программирования на другой язык программирования, обычно более близкий к оборудованию, часто напрямую исполняемый машинный код.

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

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

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

Во-первых, пояснение: Java не является полностью статически скомпилированной и скомпилированной так, как C ++. Он компилируется в байт-код, который затем интерпретируется JVM. JVM может выполнять своевременную компиляцию на родном машинном языке, но не обязана этого делать.

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

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

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

Что касается генерации исполняемых файлов, это не имеет к этому никакого отношения, ИМХО. Часто можно создать исполняемый файл из скомпилированного языка. Но вы также можете создать исполняемый файл из интерпретируемого языка, за исключением того, что интерпретатор и среда выполнения уже упакованы в исполняемый файл и скрыты от вас. Это означает, что вы, как правило, по-прежнему оплачиваете затраты времени выполнения (хотя я уверен, что для некоторых языков есть способы перевести все в исполняемый файл в виде дерева).

Я не согласен с тем, что все языки можно сделать интерактивными. Некоторые языки, такие как C, настолько привязаны к машине и всей структуре ссылок, что я не уверен, что вы сможете создать значимую полноценную интерактивную версию.

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

Книга Python © 2015 Imagine Publishing Ltd просто подчеркивает разницу следующей подсказкой, упомянутой на странице 10 как:

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

Компиляция - это процесс создания исполняемой программы из кода, написанного на скомпилированном языке программирования. Компиляция позволяет компьютеру запускать и понимать программу без необходимости в программном обеспечении, используемом для ее создания. Когда программа компилируется, она часто компилируется для конкретной платформы (например, платформы IBM), которая работает с IBM-совместимыми компьютерами, но не для других платформ (например, платформы Apple). Первый компилятор был разработан Грейс Хоппер во время работы над компьютером Harvard Mark I. Сегодня большинство языков высокого уровня будут включать свой собственный компилятор или иметь доступные наборы инструментов, которые можно использовать для компиляции программы. Хорошим примером компилятора, используемого с Java, является Eclipse, а примером компилятора, используемого с C и C ++, является команда gcc. В зависимости от размера программы для компиляции может потребоваться несколько секунд или минут, и если при компиляции не обнаружено ошибок, создается исполняемый файл. Проверьте эту информацию.

Краткое (неточное) определение:

Скомпилированный язык. Вся программа сразу переводится в машинный код, затем машинный код запускается центральным процессором.

Интерпретируемый язык: программа считывается построчно, и как только строка считывается, машинные инструкции для этой строки выполняются центральным процессором.

Но на самом деле в наши дни лишь немногие языки компилируются или интерпретируются чисто, часто это смесь. Более подробное описание с картинками смотрите в этой ветке:

В чем разница между компиляцией и интерпретацией?

Или мой более поздний пост в блоге:

https://orangejuiceliberationfront.com/the-difference-between-compiler-and-interpreter/