Что такое моджо🔥? Введение в язык программирования Mojo.

Моджо🔥

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

Разработчики Mojo полны решимости избежать создания фрагментированной программной экосистемы и хотят избавить пользователей Python от проблем, возникающих при переходе с Python 2 на Python 3. Они понимают важность этих целей, но стремятся к их достижению.

Хотя Mojo — это новая кодовая база, разработчикам повезло, что они опираются на существующие концепции. Используя Python, они упрощают процесс проектирования, поскольку большая часть синтаксиса уже определена. Это позволяет им сосредоточиться на разработке модели компиляции Mojo и функций системного программирования. Они также извлекли ценные уроки из других языков, таких как Rust, Swift, Julia, Zig, Nim, и опираются на свой опыт миграции разработчиков на новые компиляторы и языки. Кроме того, они используют существующую экосистему компилятора MLIR для дальнейшего улучшения Mojo.

Долгосрочное видение Mojo состоит в том, чтобы предоставить расширенный набор Python, сделав его совместимым с существующими программами Python. Разработчики стремятся использовать реализацию CPython для поддержки длинной экосистемы. Они хотят, чтобы Mojo сразу же казался программистам Python знакомым, предоставляя при этом новые инструменты для разработки безопасного и производительного кода системного уровня, который обычно требует C и C++ при работе с Python.

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

На основе Python

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

Для Modular Python является незаменимым компонентом их поверхностного стека API, движимого потребностями клиентов. Учитывая, что остальная часть их стека открыта для переговоров, для них логично принять подход «Python-first».

С субъективной точки зрения Modular считает Python красивым языком. Он разработан с учетом простоты и компоновки, избегая ненужной пунктуации, которая на практике становится избыточной благодаря отступам. Python также включает в себя мощные и динамичные функции метапрограммирования. Эти качества дают Modular возможность расширять язык в соответствии со своими потребностями. Они надеются, что люди в экосистеме Python воспринимают Mojo как средство продвижения Python на новый уровень, его завершения, а не конкуренции с ним.

Совместимость с Python

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

Импорт существующих модулей Python: Mojo обеспечивает 100% совместимость с точки зрения импорта и использования существующих модулей Python в программах Mojo. Это стало возможным благодаря использованию CPython для полной совместимости.

Перенос кода Python в Mojo: Однако полная совместимость для переноса кода Python в Mojo еще не достигнута. Хотя Mojo уже поддерживает несколько основных функций Python, таких как async/await, обработка ошибок и вариативность, он все еще находится на ранних стадиях разработки и не имеет многих других функций Python. Примечательно, что в Mojo еще не реализована даже поддержка классов.

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

Путь к компилятору Clang, который действует как «совместимая замена» для существующих компиляторов, таких как GCC и MSVC, для таких языков, как C, C++, Objective-C, CUDA и OpenCL. Хотя провести прямое сравнение сложно, сложность проблемы Clang кажется значительно больше, чем реализация совместимой замены Python.

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

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

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

Отличие от питона

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

Использование совместимости с CPython: Mojo использует CPython для выполнения существующего кода Python 3 без каких-либо модификаций, используя его среду выполнения в неизменном виде. Такой подход обеспечивает полную совместимость со всей экосистемой Python. Хотя запуск кода таким образом может не дать немедленных преимуществ, характерных для Mojo, доступность обширной экосистемы Python значительно ускоряет принятие и разработку Mojo. Кроме того, сильные стороны Python в высокоуровневом программировании дополняют цели Mojo.

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

Сочетая эти подходы, Mojo эффективно интегрируется в среду, преимущественно основанную на CPython. В то же время программисты Mojo могут постепенно переводить свой код, модуль за модулем или файл за файлом, в Mojo. Эта стратегия прогрессивной миграции черпает вдохновение из успешной миграции с Objective-C на Swift, выполненной Apple.

Хотя создание оставшихся функций Mojo и реализация поддержки миграции потребуют времени и усилий, команда уверена, что эта стратегия позволит им сосредоточить свои усилия и избежать отвлекающих факторов. Более того, они считают, что отношения между Mojo и CPython могут развиваться в обоих направлениях. Они предвидят будущее, в котором команда CPython может повторно реализовать интерпретатор на Mojo вместо C, демонстрируя потенциал и волнение такой перспективы.

На пути к решению проблем Python

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

Python не лишен известных проблем. Наиболее заметными среди них являются низкая производительность на низком уровне и детали реализации, специфичные для CPython, такие как глобальная блокировка интерпретатора (GIL), которая ограничивает выполнение Python однопоточным выполнением. В то время как многочисленные текущие проекты направлены на устранение этих ограничений, проблемы, связанные с Python, лежат глубже и имеют серьезные последствия, особенно в области искусственного интеллекта. Хотя мы не будем здесь углубляться в технические тонкости, мы обсудим их последствия в контексте 2023 года.

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

Проблема двух миров

В силу различных факторов Python плохо подходит для системного программирования. Однако Python превосходен в качестве связующего слоя, обеспечивая бесшовную интеграцию с низкоуровневыми привязками к таким языкам, как C и C++. Эта функция позволила разработать мощные библиотеки, такие как NumPy, TensorFlow, PyTorch и многие другие, в экосистеме Python, предлагая улучшенные характеристики производительности.

К сожалению, хотя этот подход доказал свою эффективность при создании высокопроизводительных библиотек Python, он имеет определенные недостатки. Процесс создания этих гибридных библиотек очень сложен. Это требует глубоких знаний внутренней работы CPython, владения такими языками, как C/C++ (что подрывает первоначальный замысел использования Python), препятствует развитию крупных фреймворков и, в случае машинного обучения, имеет тенденцию способствовать «на основе» моделей программирования, которые менее удобны в использовании по сравнению с системами «нетерпеливого режима». TensorFlow и PyTorch столкнулись со значительными проблемами, связанными с этими проблемами.

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

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

Проблема трех миров и N-миров

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

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

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

Мобильное и серверное развертывание

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

Улучшение CPython и JIT-компиляции Python

В последнее время сообщество Python приложило значительные усилия для повышения производительности CPython и решения проблем реализации, что дало впечатляющие результаты. Эта работа заслуживает похвалы, поскольку она постепенно улучшает существующую реализацию CPython. Например, Python 3.11 добился повышения производительности на 10–60 % по сравнению с Python 3.10 за счет внутренних улучшений, а Python 3.12 нацелен на дальнейшее продвижение с помощью оптимизатора трассировки. Многочисленные другие проекты также посвящены решению проблемы глобальной блокировки интерпретатора (GIL), в то время как такие инициативы, как PyPy и другие, используют методы JIT-компиляции и трассировки для ускорения выполнения Python.

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

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

Другие языки, подобные Python, и подмножества Python

Было предпринято несколько попыток создать «развертываемую» версию Python, такую ​​​​как TorchScript, в рамках проекта PyTorch. Эти инициативы ценны, поскольку они часто предлагают решения для развертывания с минимальными зависимостями и иногда демонстрируют высокую производительность. Из-за их синтаксиса, подобного Python, они, как правило, более доступны для учащихся по сравнению с совершенно новыми языками.

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

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

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

— — —

Почему программист Python использовал лестницу при развертывании своего кода?

Потому что они хотели достичь новых высот в развертывании и избежать ловушек с зависимостями!

🙂🙂🙂