For Machine Learning and Artificial Intelligence, Python has always appeared to be the dominant programming language, with powerful libraries such as NumPy, TensorFlow, and PyTorch. But a quick check on these libraries’ GitHub pages will show you that much of their source code is written in C and C++.
This is because Python is too slow for AI. Mojo is a new programming language that attempts to combine the speed of C/C++ with the elegance of Python.
Mojo: An Overview
Mojo is a new programming language that is syntactically similar to Python but has the speed of C. It is primarily meant for Artificial Intelligence and Systems Development, both of which are fields that require high-performance software.
It uses the SIMD – Single Instruction, Multiple Data paradigm to take advantage of parallelism. It is also just-in-time compiled and is memory-efficient.
Mojo, however, is not a completely new language; it is a superset of Python. This means that it is Python plus additional features. Similar to how TypeScript extends JavaScript. This is good because if you already know Python, it shouldn’t be too hard to pick up Mojo.
Mojo is developed by Modular, a company founded by Chris Lattner – the creator of LLVM and the Swift programming language.
In conclusion, Mojo is a new programming language designed to be syntactically similar to Python but as fast as C/C++. It is meant to be used in AI development and Systems programming. While the project is not complete, it is incredibly promising, and in the next section, we will discuss why.
Features of Mojo Over Other Programming Languages
Mojo has grown incredibly popular even though it isn’t publicly available yet. This is because it carries several significant advantages over other programming languages when performing Machine Learning and building System-level software. In this section, we will discuss these advantages.
#1. Native Support for AI and Machine Learning Tasks
Mojo is meant for developing Artificial Intelligence applications. As a result, it comes with functions and modules in the standard library for building neural networks, performing computer vision, and preparing data.
Most general-purpose languages like Python would require additional libraries to pull this off, but Mojo supports it right out of the box.
#2. Simplified Syntax and High-Level Abstractions
To write fast and efficient software, we would normally need to use languages like C, C++, and Rust. While these languages are fast, they are more challenging to learn and work with. This is because they force you to work at a low level so you have more control.
However, Mojo still provides higher-level abstractions like Python and simple syntax. This makes it easier to work with than other languages comparable in performance.
#3. Integration With Popular AI Frameworks and Libraries
As mentioned earlier, Mojo is not a completely new language – it is a superset of Python. As a result, it integrates well with existing libraries such as NumPy and PyTorch. This means that, by default, Mojo has an ecosystem as big as Python’s.
#4. Efficient Data Handling and Manipulation Capabilities
Mojo is designed to manipulate multiple values efficiently in parallel. This is most useful when performing linear algebra, that machine learning relies so heavily on. Mojo is also just-in-time compiled, so the bytecode is optimized for speed. This makes working with data and machine learning efficient in Mojo.
#5. Scalability and Parallel Computing Support
As mentioned earlier, Mojo is built to support the Single Instruction – Multiple Data paradigm of parallel computing. This comes built into Mojo and makes it faster out of the box. It also outperforms Python libraries such as NumPy.
Key Elements of Mojo
In this section, we will discuss how to write programs in Mojo. Because Mojo is meant to be a superset of Python, like how TypeScript is a superset of JavaScript, all valid Python code is valid Mojo code, but not all Mojo code is valid Python code.
Mojo is still a work in progress, and some Python language features are not supported yet — for example, classes. In addition, a compiler is not available as yet, but you can use Mojo in a playground notebook. However, you will need an account first, which you can create on their website.
At the moment, it is hard to give a comprehensive tutorial on the language as some features are yet to be added, and not all things are currently supported. Instead, we will discuss some key additions that Mojo adds on top of what Python already has.
Syntax and Grammar
Because Mojo is a superset of Python, their syntaxes are identical. Like Python, a program is made up of statements. These statements can be grouped into blocks under functions, loops, or conditionals. Statements inside a block are indented. Here’s an example program written in Mojo:
def odd_or_even():
for i in range(1, 101):
if i % 2 == 0:
print("Even")
else:
print("Odd")
odd_or_even()This is perfectly identical to a Python program. However, Mojo offers additional features that you will see in the sections to follow.
Variable Declarations
With Mojo, you have two additional ways of declaring variables. You can use either the let or var keyword. The let keyword declares an immutable variable. Once initialized, you cannot reassign its value to something else. On the other hand, variables declared using var can be reassigned as they are mutable.
The main advantage of variables declared using let or var is that they support type specifiers. The following example illustrates how variables are declared in Mojo.
let pi: Float64 = 3.141
var greeting = "Hello, World"
# This would be impossible
# pi = 6.283
# But this is possible
greeting = "Ola"
print(pi, greeting)Structs
In addition, to a different way of declaring variables, Mojo supports structs. A simple way to view structs is they are like classes except more rigid. Unlike classes, you cannot add/remove or modify methods while running, and all members have to be declared using the var or let keywords. This more rigid structure enables Mojo to manage memory and performance more effectively. Here’s an example struct:
struct Person:
var name: StringLiteral
var age: Int32
fn __init__(inout self, name: StringLiteral, age: Int32):
self.name = name
self.age = age
john = Person("John Doe", 32)
print(john.name, john.age)Functions
From the struct above, you might have noticed that we declared the __init__ method using the fn keyword instead of def. This is because, in Mojo, you can declare functions using fn and def. A function declared using fn is stricter compared to its def counterpart.
Specifically, a function declared using fn has its arguments immutable by default. In addition, you are required to specify the data type of arguments and the function’s return value. All local variables must be declared before use.
fn say_hello(name: StringLiteral):
print("Hello,", name)
# This would be invalid
# fn say_hello(name):
# print("Hello,", name)
say_hello("John")If the function raises an exception, it must be explicitly stated when the function is declared using the raises keyword. In addition, Mojo does not use the Exception class like Python does, instead, it uses the Error class.
fn will_raise_error() raises:
raise Error('Some error')
will_raise_error()Overloading
Mojo also supports overloading operators based on different datatypes. This supports the object-oriented principle of polymorphism.
fn add_numbers(a: Int32, b: Int32) -> Int32:
return a + b
fn add_numbers(a: Int32, b: Int32, c: Int32) -> Int32:
return a + b + c
let first_total = add_numbers(2, 3)
let second_total = add_numbers(1, 2, 3)
print(first_total, second_total)How Mojo Is Used in AI Development
Mojo comes with libraries for building Machine Learning models. These include libraries for building neural networks. In addition, you can also perform tasks such as Natural Language Processing and Computer Vision.
While the language itself is yet to be completed, and its ecosystem is virtually nonexistent, we can still expect that Mojo will bring many features to perform tasks such as data processing, model creation, optimization, model management, and monitoring.
Is Mojo the Future of AI Development
It is hard to predict how technology is likely to evolve and be adopted. Most predictions are wrong, but that does not mean we cannot try. To predict whether Mojo is likely to replace Python, let’s consider Mojo’s benefits and drawbacks/limitations:
Benefits
- It is very fast and built to take advantage of parallelism without doing much, which is essential for machine learning as training models can take lots of time.
- It is a superset of Python, therefore, easier to learn and has a gentler learning curve. This reduces friction for adoption.
- It reduces the chances of getting errors in production as errors such as mistyped variable names or type mismatches are caught during compile time. This makes it preferable.
Drawbacks
- It is currently incomplete. But of course, the team at Modular is working on releasing the language and its translator.
- As much as it simplifies the work of framework producers, it may not carry much of an advantage to framework consumers since they already use Machine learning frameworks in Python.
- It does not have a large ecosystem of tools and learning resources yet. While you can use Python’s libraries in Mojo, you can still use Python’s libraries in Python. For Mojo to carry any advantage over Python, it needs libraries that carry the speed of Mojo.
Final Words
If the current hype is anything to go by, Mojo is likely to become a popular AI language. I think its speed alone is enough to encourage people to switch over. Its simplicity is a plus. But like how TypeScript did not replace JavaScript completely, it is likely that Mojo will not replace Python completely.
Mojo is definitely a language to keep on your radar for when it eventually matures.
Next, check out Type vs. Interface in TypeScript.
