Why Choose Mojo?

Currently, Mojo is a proprietary language created by Modular, an AI company aiming to establish a cohesive AI platform that simplifies development while enhancing performance. Mojo addresses challenges related to AI infrastructure scaling and acceleration. Notably, it is the first language built using MLIR, a compiler framework optimized for diverse hardware, including modern CPUs and GPUs. In essence, Mojo is a groundbreaking language for AI applications.

Mojo vs. Python

Designed to be an advanced version of Python, Mojo resembles TypeScript's relationship with JavaScript, enhancing its foundational language. This similarity means that Python developers can easily transition to Mojo.

While Python dominates in machine learning and data-centric fields, it faces challenges related to low-level performance and the global interpreter lock (GIL), which complicates concurrency. These limitations contribute to the perception of Python as slow and hinder its development. Consequently, Python often serves as a "glue" language, with core functionalities developed in more efficient compiled languages like C.

Mojo aims to bridge the gap between Python's accessibility and the efficiency of compiled languages such as C and Rust. It embraces the Python community, striving to simplify learning by abstracting complexities like compilation and memory management.

In this article, we will delve into the basics of Mojo through direct comparisons with Python. We will cover essential topics such as variables, functions, and structs, ultimately comparing the performance of Mojo and Python for similar code snippets.

Installing Mojo

To install Mojo on a Linux machine, use the following commands:

modular auth mut_73b76eabd7a04555be4daa751d3e7088

modular install mojo

After installation, you'll receive setup instructions in the console.

To get started, the print command functions identically to that in Python, allowing you to write your first "Hello World" in Mojo easily. Remember to exit the Mojo REPL by typing a colon : followed by quit, as opposed to using quit() like in Python.

Variables in Mojo

Creating variables in Mojo is straightforward, akin to Python. For example:

x = 1

This declaration creates a mutable variable, meaning its value can change:

x = 2

print(x) # Output: 2

However, since Mojo is strictly typed, changing a variable's type will result in an error:

x = "a" # Error: cannot implicitly convert 'StringLiteral' value to 'Int'

While declaring variables without var or let is possible, it is not a best practice. Instead, the var keyword is used for mutable variables, while let defines immutable variables.

For instance, using let:

let x = 1

x = 2 # Error: expression must be mutable in assignment

Although Mojo aims to be a superset of Python, its syntax can differ in certain cases, particularly regarding type annotations:

var x: Int = 1

var y: String = "a"

var z: Bool = True

Functions in Mojo

Functions in Mojo can be defined using either the fn or def keyword. The fn declaration enforces type-checking and memory safety, similar to Rust, while def allows for dynamic behavior without type declarations, akin to Python.

Here’s how you would define a simple function in both styles:

Using def:

def sum_up(n):

sum = 0

for i in range(1, n+1):

sum += i

return sum

Using fn:

fn sum_up(n: Int) -> Int:

var sum: Int = 0

for i in range(1, n+1):

sum += i

return sum

The fn keyword ensures strict type adherence and compile-time checks, while def serves to ease the transition for Python users.

Mojo Structs

Structs in Mojo are akin to classes in Python, supporting properties and methods. Below is a simple class definition in Python:

class Dog:

def __init__(self, name):

self.name = name

def run(self):

print(f"{self.name} is running.")

The corresponding struct in Mojo looks like this:

struct Dog:

var name: String

fn __init__(inout self, name: String):

self.name = name

fn run(self):

print(self.name, " is running.")

Key differences include the requirement to define properties before assigning values in the constructor. The keyword inout is used for mutable references, which is a more complex concept not elaborated upon here.

Comparing Performance: Python vs. Mojo

Now that we’ve covered the basics, let’s compare the performance of Python and Mojo. Consider the following Python code saved in a file named sum_up.py:

def sum_up(n):

sum = 0

for i in range(1, n + 1):

sum += i

return sum

def main():

print(sum_up(1000000000))

if __name__ == "__main__":

main()

And the equivalent Mojo code in sum_up.mojo:

fn sum_up(n: Int) -> Int:

var sum: Int = 0

for i in range(1, n + 1):

sum += i

return sum

fn main():

print(sum_up(1000000000))

To measure execution time in Linux, use the time command:

For Mojo:

$ time mojo sum_up.mojo

For Python:

$ time python sum_up.py

The Mojo code executes in a fraction of a second, while the Python code takes significantly longer. This stark contrast is due to Mojo being a compiled language, whereas Python is interpreted. The fact that the syntax remains similar to Python is a major advantage for developers transitioning to Mojo.

Running Python Code in Mojo

In the future, as Mojo matures into a true superset of Python, it will be possible to run Python code directly in Mojo. For now, we can import Python modules and interact with them from Mojo code.

Here’s an example of how to import the sum_up.py module in a Mojo file called call_python_in_mojo.mojo:

from python import Python

fn main() raises:

Python.add_to_path(".")

let mypython = Python.import_module("sum_up")

let result = mypython.sum_up(1000000000)

print(result)

To execute this code, run:

$ time mojo call_python_in_mojo.mojo

While the speed remains similar to running the code directly in Python, it's important to note that Mojo is still in its early stages of development, and improvements in usability and Python integration are expected.