Mojo Tutorial

Learn Mojo: The Next Generation Programming Language for AI

Mojo is an innovative programming language that combines the usability of Python with the performance of C. It is designed to be the language of choice for artificial intelligence (AI) development, since it allows developers to write code that is both fast and easy to read and write.

Here are some key points,

  • Modular is a new programming language that was created to address the challenges of programming across the entire AI stack.
  • Mojo is designed to be an innovative and scalable programming model that can target accelerators and other heterogeneous systems.
  • Mojo is built on top of the Python ecosystem, which makes it widely available and easy to use.

Why is it called Mojo?

Mojo means “a magical charm” or “magical powers.” The name is apt for a language that brings magical powers to Python, including an innovative programming model for accelerators and other heterogeneous systems ubiquitous in AI.

A member of the Python family, Mojo

  • Mojo is a new programming language that aims to be fully compatible with the Python ecosystem.
  • Mojo will provide predictable low-level performance and low-level control.
  • Mojo will allow developers to deploy subsets of code to accelerators.
  • Mojo will not create a fragmented software ecosystem Python users who adopt Mojo to draw comparisons to the painful migration from Python 2 to 3.
  • Mojo will benefit from lessons learned from other languages.
  • Mojo will be a superset of Python and will be compatible with existing Python programs.
  • Mojo will provide new tools to develop safe and performant systems-level code.
  • Mojo will allow developers to choose between static and dynamic typing.

Python's benefits:

  • Python is the dominant force in ML and countless other fields.
  • Python is easy to learn, known by important cohorts of programmers, has an amazing community, has tons of valuable packages, and has a wide variety of good tooling.
  • Python supports the development of beautiful and expressive APIs through its dynamic programming features.
  • Machine learning frameworks like TensorFlow and PyTorch embrace Python as a frontend to their high-performance runtimes implemented in C++.
  • For Modular, Python is a non-negotiable part of their API surface stack.
  • The Modular team hopes that people in the Python ecosystem see their direction for Mojo as taking Python ahead to the next level—completing it—instead of competing with it.

Python compatibility

  • Mojo is designed to be fully compatible with the Python ecosystem.
  • There are two types of compatibility: import compatibility and migration compatibility.
  • Mojo is 100% import compatible with Python because it uses CPython for interoperability.
  • Mojo is not yet fully migration compatible with Python.
  • In the case of Python and Mojo, the Mojo expects to cooperate directly with the CPython runtime and have similar support for integrating with CPython classes and objects without having to compile the code itself.
  • This provides plug-in compatibility with a massive ecosystem of existing code, and it enables a progressive migration approach in which incremental migration to Mojo yields incremental benefits.

Python’s problems

  • Python has some well-known problems, including poor low-level performance and the global interpreter lock (GIL), which makes Python single-threaded.
  • These problems are particularly impactful in the AI field, where high performance and multithreading capabilities are often required.
  • One way to address these problems is to use hybrid libraries, which are built using a combination of Python and C/C++.
  • However, building hybrid libraries is complicated and requires knowledge of both Python and C/C++.
  • This can make it difficult to evolve large frameworks and can lead to usability problems.
  • In addition, the two-world problem of having to deal with both Python and C/C++ code can make it difficult to use debuggers and other tools.
  • This is particularly problematic for AI developers, who often need to use accelerators like CUDA (Compute Unified Device Architecture).
  • CUDA (Compute Unified Device Architecture) is a bespoke programming language that has its own special problems and limitations.
  • The AI world has an incredible amount of innovation on the hardware front, and as a consequence, complexity is spiraling out of control.
  • There are now several attempts to build limited programming systems for accelerators (OpenCL, Sycl, OneAPI, and others).
  • However, none of these systems solve the fundamental fragmentation in the tools and ecosystem that is hurting the industry so badly.
  • Mojo aims to address these problems by providing a single, unified language that can be used for both systems programming and AI development.
  • Mojo is still under development, but it has the potential to revolutionize the AI industry.

Mobile and server deployment:

Another challenge for the Python ecosystem is deployment. There are many facets to this, including how to control dependencies, how to deploy hermetically compiled “a.out” files, and how to improve multi-threading and performance.

Python subsets and other Python-like languages:

  • There have been many attempts to build a “deployable” Python, such as TorchScript from the PyTorch project.
  • These languages are useful because they often provide low-dependency deployment solutions and sometimes have high performance.
  • They use Python-like syntax, which makes them easier to learn than a novel language.
  • However, these languages have not seen wide adoption because they:
    • Do not interoperate with the Python ecosystem
    • Do not have fantastic tooling (such as debuggers)
    • Change-out inconvenient behavior in Python unilaterally, which breaks compatibility and fragments the ecosystem further
  • The challenge with these approaches is that they attempt to solve a weak point of Python, but they are not as good at Python’s strong points.
  • At best, these can provide a new alternative to C and C++, but without solving the dynamic use-cases of Python, they cannot solve the "two world problem."
  • This approach drives fragmentation, and incompatibility makes migration difficult to impossible.

Follow us on Facebook and Twitter for latest update.