Компилируемый язык: Компилируемые языки: список, плюсы и минусы

Содержание

Компилируемый язык программирования | это… Что такое Компилируемый язык программирования?

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

Классификация языков программирования на компилируемые и интерпретируемые, является неточной и весьма условной, поскольку для любого языка программирования может быть создан как компилятор, так и интерпретатор. И, в действительности, существует множество языков, инструментарий которых включает в себя и компилятор, и интерпретатор (напр. Ch и CINT[1] для C или Lisp). Кроме того, существуют реализации языков, которые компилируют исходный текст программы в байт-код, который затем либо интерпретируется, либо выполняется т.  н. JIT-компилятором. Это привносит ещё больше неясности в вопрос о том, где именно должна быть проведена граница между компилируемым языком и языком интерпретируемым.

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

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

Содержание

  • 1 Применение
  • 2 Компилируемые языки программирования
  • 3 Примечания
  • 4 Ссылки

Применение

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

Компилируемые языки программирования

В этом разделе не хватает ссылок на источники информации.

Информация должна быть проверяема, иначе она может быть поставлена под сомнение и удалена.

Вы можете отредактировать эту статью, добавив ссылки на авторитетные источники.
Эта отметка установлена 30 марта 2012.

Следующие языки принято считать компилируемыми:

  • Ada
  • ALGOL
    • Algol 60
    • Algol 68
    • SMALL
  • Asm
  • BASIC (создавался как компилируемый, но многие реализации являются интерпретируемыми)
  • C
    • C++
    • Objective-C
  • CLEO
  • COBOL
  • Cobra
  • Common Lisp
  • D
  • Delphi
  • Eiffel
    • Sather
    • Ubercode
  • Fortran
  • Go
  • Java
  • JOVIAL
  • LabVIEW
  • Lush
  • ML
    • Standard ML
      • Alice
    • Ocaml
  • Pascal
  • PureBasic
  • Visual Basic
  • Visual Foxpro
  • Visual Prolog

Примечания

  1. CINT | ROOT

Ссылки

  • Компилируемые языки в dmoz.

Что такое JS? | JS: Настройка окружения

Зарегистрируйтесь для доступа к 15+ бесплатным курсам по программированию с тренажером

Что вообще такое язык программирования?

Языком программирования называют правила, по которым записывается исходный код. В отличие от естественных языков, эти правила достаточно строги. Любая мельчайшая ошибка — и код не запустится, или запустится, но не заработает как ожидается. Например, в JavaScript нельзя написать const name;. Эти правила существуют не только в книгах и головах разработчиков, пишущих программы на этом языке. Они четко описаны в спецификации — документе, который диктует правила, по которым должен работать язык.

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

Компиляция – процесс создания программы, готовой к прямому запуску. Большинство программ, с которыми мы имеем дело как пользователи, кем-то скомпилированы. Например, в Windows скомпилированные программы имеют расширение exe. Другой подход – интерпретация. При интерпретации превращение исходного кода в машинный происходит не до запуска программы, а прямо в процессе ее обработки. Именно поэтому сам подход называется интерпретацией.

JavaScript относится к интерпретируемым языкам. Для его запуска нужна специальная программа – интерпретатор. Например, когда JavaScript код выполняется на сервере, интерпретатором чаще всего выступает Node.js, когда на фронтенде — сам браузер. В других местах, таких как встраиваемые устройства или автомобили, могут быть свои собственные интерпретаторы.

В реальности все чуть сложнее. Непосредственно интерпретацию выполняет «движок», который встроен и в Node.js, и в браузеры.

// node запускает интерпретатор, который берет исходный код index. js,
// анализирует его (это называется парсинг),
// а затем построчно исполняет
node index.js

Глобально существует два больших класса языков – интерпретируемые и компилируемые. У каждой из этих групп есть свои плюсы и минусы, о которых можно почитать в разных статьях. Здесь же мы сосредоточимся на особенностях конкретно JavaScript.

Исторически JavaScript разрабатывался под самый популярный на тот момент браузер. Новый язык позволял добавлять интерактивность на страницы, хотя изначально все сводилось к снежинкам и разным визуальным эффектам. Со временем разработчики распробовали этот язык и стали активнее строить логику с его участием. Одним из самых известных поворотных моментов стало появление сервиса Gmail, который на полную катушку использовал AJAX (выполнение HTTP-запросов к серверу). JavaScript начинал играть все большую роль в создании сайтов, и уже все браузеры озадачивались его поддержкой. Для этого практически каждый крупный производитель браузера создавал свой собственный интерпретатор.

Дальнейшее развитие технологии вывело JavaScript за пределы браузера. Сначала появилась серверная реализация Node.js, затем он стал использоваться даже во встраиваемых системах. Сейчас даже утюги можно программировать с помощью JavaScript.

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

ECMAScript не стоит на месте и постоянно развивается. Каждый новый стандарт описывает какие-то дополнительные возможности языка. Одни добавляют новый синтаксис, другие дополняют стандартную библиотеку новыми встроенными функциями. Стандарты по большей части обратно совместимы: то есть код, написанный под стандарт es3, запустится на большинстве интерпретаторов. К сожалению, это не всегда происходит без ошибок. Поведение кода со временем меняется, причем обычно в сторону более строгого поведения.

Языки сценариев и компилируемые языки в WebAssembly

Обещание WebAssembly состоит в том, что он может быть общей средой выполнения для всех видов языков. Но есть различия между тем, как мы традиционно пишем на скриптовых языках (JavaScript, Python, Ruby) и компилируемыми языками (C/C++, Go, Rust). Существуют также скомпилированные языки, которые работают в интерпретаторе, например Java, работающая в JVM. В этом посте мы рассмотрим ландшафт WebAssembly, чтобы увидеть, что происходит на этих фронтах.

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

Взглянув на самые популярные языки программирования, мы увидим три разных типа языков программирования:

 1 JavaScript
2 питона
2 Ява
4 PHP
5 ССЦ
5 С++
5 С#
8 машинопись
9 рубин
10 С
 

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

Компилируемые языки

В первую десятку списка C++ (№5) и C (№10) входят языки, скомпилированные в родные. Rust и Go — два других популярных компилируемых языка, которые не попали в топ-10. Как правило, эти языки компилируются в двоичный формат, специфичный для архитектуры и операционной системы. Компилируемому языку не нужен интерпретатор или виртуальная машина для выполнения программы.

Компилируемые языки получили раннюю поддержку WebAssembly. На самом деле все четыре (C, C++, Rust и Go) можно скомпилировать в WebAssembly. Это может показаться удивительным, поскольку эти языки обычно компилируются для каждой архитектуры и ОС. То есть программа на C обычно должна быть скомпилирована одним способом для запуска на ARM и Linux и скомпилирована другим способом для работы в macOS с процессором Intel (иногда код должен быть изменен для каждой платформы). Но когда они скомпилированы в WebAssembly, они могут работать в любой среде выполнения WebAssembly независимо от операционной системы, архитектуры или других подобных деталей низкого уровня.

Когда дело доходит до поддержки компиляторов WebAssembly, Rust и C идут дальше всех, каждый из которых имеет безупречную поддержку. Поддержка C++ обеспечивается компиляторами C и, следовательно, также хорошо поддерживается. Официальный дистрибутив Go (принадлежащий Google) немного отстает, но проект TinyGo компенсирует разницу. Все эти языки готовы к использованию в WebAssembly.

По сути, компиляция одного из этих «родных» языков в WebAssembly означает, что они ведут себя больше как языки виртуальных машин.

Языки виртуальной машины

В первую десятку вошли два языка виртуальных машин: Java (№2) и C# (№5). Другие популярные языки виртуальных машин включают Scala, F# и Kotlin. Эти языки компилируются, но не в собственный код. Они компилируются в промежуточный формат, обычно называемый «байт-код». Затем этот код загружается в специальную среду выполнения или в виртуальную машину (JVM для Java или CLR для C#).

.NET (включая C#, F# и ASP.net) имеет отличную поддержку WebAssembly в браузере, и мы знаем, что команда Microsoft работает над многими другими улучшениями.

Поддержка Kotlin развивается быстро, и есть ряд проектов для Java и Scala.

Поскольку эти языки перенесены в WebAssembly, им больше не понадобятся среды выполнения для конкретных языков. Например, Kotlin не понадобится JVM. Он будет скомпилирован непосредственно в WebAssembly, который может быть выполнен непосредственно во время выполнения WebAssembly.

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

Сценарные (интерпретируемые) языки

Пять языков сценариев вошли в десятку лучших языков программирования: JavaScript (№1), Python (№2), PHP (№4), TypeScript (№8) и Ruby (№9). Языки сценариев обычно не компилируются. Вместо этого код передается непосредственно в интерпретатор во время выполнения. Интерпретатор читает и выполняет программу на лету. Поскольку код загружается и выполняется в тандеме, среды языков сценариев иногда делают то, чего не могут компилируемые языки. Например, включение новой части исходного кода во время выполнения является тривиальной задачей, в то время как это не является функцией большинства компилируемых языков.

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

Из языков сценариев, входящих в первую десятку, JavaScript находится в стадии наиболее активной разработки. Примечательно, что движок SpiderMonkey, лежащий в основе реализации JavaScript в Firefox, теперь компилируется в WebAssembly.

По состоянию на январь 2022 года и Ruby, и Python теперь могут компилировать свои соответствующие среды выполнения в WebAssembly. Хотя в обоих случаях поддержка Wasm находится на ранней стадии, мы считаем, что теперь, когда самая сложная часть сделана, они очень быстро созреют. (На горизонте у нас есть несколько сообщений в блоге, чтобы показать Ruby и Python в действии!)

TypeScript обычно переводится в JavaScript. Затем сгенерированный файл загружается в интерпретатор JavaScript. Таким образом, успех JavaScript автоматически принадлежит TypeScript. Но у разработчиков TypeScript есть интересная альтернатива. AssemblyScript — это надмножество TypeScript, которое компилируется в WebAssembly. Хотя он сохраняет ощущение языка сценариев, в конечном итоге он ведет себя как скомпилированный язык.

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

Языки сценариев могут стать компилируемыми языками

И последнее замечание относительно текущих различий в языках. С WebAssembly компилируемые языки, такие как C, Rust и Go, фактически становятся языками виртуальных машин. Можем ли мы ожидать, что то же самое произойдет и в мире сценариев? Будут ли языки сценариев предварительно компилироваться в двоичные файлы WebAssembly?

Есть некоторые основания полагать, что ответ на этот вопрос будет положительным.

  • Общая модель выполнения упрощает работу с WebAssembly. А двухэтапную загрузку скриптовых языков можно было бы заменить одноэтапной.
  • Производительность тоже проблема. Трудно оптимизировать двухстадийный процесс настолько, насколько можно оптимизировать одностадийный процесс.
  • Избыточность кода — третья причина: прямо сейчас каждый скрипт Python, ориентированный на WebAssembly, должен поставляться с полной копией среды Python. При компиляции конечного кода в Python неиспользуемые части среды Python могут быть удалены во время компиляции, что приведет к уменьшению размера приложения
  • .
  • AssemblyScript уже лидирует, разделяя дизайн TypeScript, но компилируя непосредственно в байт-код WebAssembly.

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

Заключение

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

Руководство по компилируемым и интерпретируемым языкам программирования — GameDev Academy

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

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

Содержание

Как работают компьютеры

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

Машинный код и двоичный код

По сути, компьютеры — это просто набор электрических сигналов. Иногда мы отключаем эти сигналы, а иногда включаем их. В некотором смысле вы можете думать об этом как о более элементарной версии азбуки Морзе. И, подобно азбуке Морзе, мы можем присвоить этим электрическим сигналам значения.

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

В этот момент, однако, вы можете спросить, зачем проектировать компьютеры именно так? Ну, по сути, для того, чтобы компьютеры работали так же быстро, как они, нам нужны были как можно более простые числовые значения для подачи на ЦП. Без этого компьютеры, вероятно, вечно работали бы так же медленно, как коммутируемый доступ в Интернет, к которому вы пытаетесь получить доступ с удаленного острова. Таким образом, это чистое решение дало нам скорость, необходимую для выполнения всего, что мы делаем на компьютерах.

Что такое язык программирования?

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

Вместо этого люди нашли более простой способ обойти это: языков программирования .

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

Однако, как вы могли догадаться, мы не можем передать этот удобочитаемый язык компьютеру, который действительно понимает только двоичный код. Итак, нам нужен какой-то способ перевести то, что говорит язык программирования, в двоичный формат, который может прочитать компьютер. Возможно, если бы у нас был какой-то способ составить этот перевод или, может быть, даже интерпретировать его на месте?

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

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

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

Что такое компилируемый язык?

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

Примеры популярных компилируемых языков: C++, C#, F#, Go, Kotlin, Python (также можно интерпретировать), Rust, Swift

Что такое интерпретируемый язык?

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

Примеры популярных интерпретируемых языков: JavaScript, Lua, Perl, PHP, Python (также можно компилировать), Ruby, PowerShell

Что такое компилятор Just-In-Time?

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

Примеры языков, которые могут использовать JIT-компиляторы: Java, C#, Scala, Visual Basic

Компилируемые и интерпретируемые: преимущества и недостатки

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

Скорость выполнения

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

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

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

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

Шаги компиляции

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

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

Однако, как было установлено ранее, скомпилированные языки нуждаются в дополнительном шаге «сборки», чтобы перейти от кода к исполняемому приложению. Продолжительность этого шага сборки сильно различается от программы к программе и во многом зависит от сложности. Например, ваш простой скрипт «Hello World», скорее всего, скомпилируется менее чем за 1 секунду. С другой стороны, ваша игра с открытым миром с сотнями персонажей и сценариями, вероятно, займет в лучшем случае несколько минут.

Обе «скорости» можно рассматривать как пару компромиссов. Компилируемые языки жертвуют «скоростью» компиляции ради более быстрого выполнения, а интерпретируемые языки жертвуют скоростью выполнения ради более быстрой компиляции.

Гибкость модификации

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

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

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

Обработка ошибок компиляции

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

Компилируемые языки полностью не позволят вам скомпилировать что-либо, если есть ошибки кодирования, которые могут повлиять на компиляцию. Как правило, большинство компиляторов просто останавливают процесс трансляции и уведомляют вас о том, почему процесс компиляции не удался. С одной стороны, это делает так, что вы не выполняете программы, которые в любом случае имели бы критические ошибки. Таким образом, это позволяет решать проблемы до того, как они станут проблемами. Однако это может затруднить отладку программ, поскольку вы не можете протестировать выполнение, не исправив определенные ошибки — некоторые ошибки, которые вам может быть трудно найти без этого выполнения.

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

В общем, все зависит от того, чего вы хотите как разработчик!

Переносимость

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

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

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

Почему скомпилированное и интерпретированное имеет значение

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

Разные программы требуют разной скорости выполнения

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

Например, обратите внимание на разницу между играми, предназначенными только для браузера, и играми класса AAA, такими как Soulcalibur VI . Большинство браузерных игр создаются с помощью JavaScript, интерпретируемого языка, и поэтому имеют меньший масштаб. Во многом это связано с тем фактом, что интерпретируемые языки несколько ограничивают скорость работы этих игр. Таким образом, чтобы избежать задержек, разработчики должны уменьшить их размер — графически или программно.

Однако с Soulcalibur VI , здесь гораздо больше возможностей для сложной графики и механики. Поскольку эта игра была основана на C++, скомпилированном языке, игра может использовать преимущества скорости, чтобы обеспечить более полный опыт с интенсивной 3D-графикой, чего вы не могли бы получить в браузерной игре.

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

Редактирование кода должно быть быстрее или проще

Когда вы начинаете погружаться в концепции более высокого уровня, такие как машинное обучение, последнее, что вы, как разработчик, захотите делать, это засорять внешний интерфейс время компиляции. К сожалению, компилируемые языки делают именно это, даже если компиляция вашего проекта занимает менее 1 секунды. Иногда вам действительно нужно иметь возможность быстро протестировать определенные функции, строки кода и т. д., чтобы завершить его. А иногда вам может потребоваться выполнить тесты в реальном времени, чтобы убедиться, что определенные данные обрабатываются правильно.

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

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

Кроссплатформенность

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

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

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

Ending Words

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

Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *