Python is one of the most popular programming languages in the world. From recommendation algorithms to self-driving cars and robotics, the use case possibilities are endless. In our quest to explore the dynamic world of Python, we sat down with Darshan, a seasoned software developer at arculus. His insights shed light on the diverse applications the language serves within arculus and the reason behind its adoption. Join us as we delve into the world of programming through the lens of Darshan's experiences and expertise.

A first look into Python

Whether you're a seasoned developer or a passionate tech enthusiast, the odds are that Python has left its mark on your digital journey. The language, first released by Guido van Rossum in 1991, is present in a huge variety of modern applications. In fact, research conducted by code hosting platform GitHub in 2022, found Python to be the 2nd most used language for four years in a row, with four million developers using it in 2022.

But what actually is Python?

Python was born from van Rossum’s desire to write a clean and aesthetically pleasing language. And if you're wondering how a programming language can have these qualities, check out a simple piece of code in both Java and Python:

Python

print("Hello world.")

Vs.

Java

public class HelloWorld {
    public static void main (String[]args) {
      System.out.println.("Hello world");
    }
}

The Python Software Foundation defines it as “an interpreted, interactive, object-oriented programming language”. Let’s break down what each of these characteristics means:

• Interpreted: developers don't need to compile the code before running it. Instead, the Python interpreter reads and executes the code line by line, making development more flexible.
• Interactive: developers can interact with the Python interpreter in real time. This interactive mode, often used in the Python shell (REPL - Read-Eval-Print Loop), enables them to enter and execute code snippets one at a time. It's useful for testing small code snippets, experimenting, and learning.
• Object-oriented: Python follows the principles of object-oriented programming (OOP), where developers arrange code into objects or classes, each encapsulating data and behaviour. OOP promotes modularity, reusability, and a more organised approach to solving complex problems. Python allows the creation and use of objects, making it suitable for developing large and complex applications.

Why is Python so popular?

To better understand the popularity of Python and its crucial role in the arculus tech stack, we asked software engineer Darshan Patel to explain some of the language’s key advantages:

Rapid Prototyping

“Python is a dynamically typed language with ‘batteries included’. This means that it ships with a lot of functionality for performing various tasks, with less overhead compared to statically typed languages”, highlights Darshan. “It also offers the benefits of quickly implementing abstract ideas into something that is ‘almost tangible’, interactive and easily perceivable by everyone. These qualities allow us to quickly iterate over the product, gather feedback and reduce the time to market,” he continues.

Beginner-friendly

Darshan describes Python as having a “very gentle learning curve”. In other words, beginners and experienced programmers alike can easily learn the languages. “Its syntax is also very human friendly and close to natural language. This offers great readability and understandability concerning the existing code”, he explains.

Great community and learning tools

Along with Python’s numerous inbuilt functionalities comes a plethora of online/offline resources available to tackle all sorts of problems. “Resources like libraries, books, courses and tutorials are abundant and can be employed to tackle almost any problem. Furthermore, it has a lively, diverse and inclusive community of people who contribute to teaching, creating and maintaining the aforementioned resources. The community is also happy to help via channels like Forums, Q/A sites and even Discord Servers”, explains Darshan.

Expansive reach

“I would categorise Python as a ‘Jack of all trades’ among existing programming languages because it is ubiquitous within various technical/scientific fields”, defines Darshan. He explains that many disciplines and fields employ Python to solve all kinds of tasks. “This prevalence makes it one of the top choices, since problems from various fields can be tackled using the same language”, he concludes.

Other Python benefits that stand out are:

• It’s open source: Python’s source code is freely available for anyone to view, use, modify, and distribute.
• It’s portable: Python code can run on different platforms without significant modifications, ensuring broad application compatibility.
• It’s extendable: Developers can enhance Python's functionality by adding external libraries and modules.

Python’s libraries

Libraries are “cornerstones of modern software development. They offer pre-built solutions to a variety of problems which can be directly incorporated into the application, rather than writing the solution by hand”, defines Darshan. “Functions like file operations, network communication, Data Structures and Algorithms are commonly used over a wide range of applications. And libraries offer the means to implement such functions with minimal effort. This ultimately reduces the time required to implement the application”, he concludes.

Although most programming languages offer their sets of libraries, Python shines on two fronts here:

1. Python’s standard (or internal) library comes with an extensive collection of built-in modules and packages that provide a wide range of functionality right out of the box. “On the other hand, languages like C or Rust are shipped with a more conservative amount of internal libraries. So, projects in these languages tend to rely on a high number of external libraries.”
2. Python’s strong community also ensures that the language boasts one of the most extensive ecosystems of third-party libraries and packages among programming languages. They cover virtually every domain, from web development and data science to machine learning, artificial intelligence, and scientific computing. Some prominent examples include:

• Numpy: Offers high-performance data structures for performing computations.
• Matplotlib: Offers means to visualise and analyse data.
• Qt: Provides GUI (Graphical User Interface) frameworks
• Networkx: Offers data structures and algorithms for network analysis.

The not-so-bright side of Python

Despite its many benefits, working with Python doesn’t come without challenges. For Darshan, there are three main disadvantages associated with programming in Python. Here is a closer look:

1. Limited Performance: "One of the primary challenges of using Python is its limited performance. Being a dynamically typed language, the interpreter has to perform 'checks and balances' while the code is being executed," defines Darshan. These checks and balances lead to overhead during program execution, which can hinder performance.
2. Concurrency and Multithreading: Darshan also highlights an issue related to modern computer hardware, which often includes multiple processing units known as cores. He explains, "Modern systems have several cores. Python, however, by default, doesn't efficiently use them due to certain technical constraints in how Python code runs." This means that Python programs may only fully benefit from the extra computing power available in multi-core computers if developers specifically design their programs to do so, which can be a complex task.
3. Type Safety Challenges: Python's dynamic nature means it doesn't provide inherent type safety by default. “As a program becomes larger and more complex, ensuring the consistent use of the right data types across various parts of the application, can become increasingly challenging," points out Darshan. However, modern Integrated Development Environments (IDEs) and code editors include type checkers that promptly alert developers to potential type-related issues. Additionally, external libraries are available that perform static type analysis, proactively checking the codebase for any type misuse.

Python in the real world

Despite its challenges, Python is still one of the most extensively used programming languages across multiple use cases. It serves as a go-to language for data analysis and machine learning, enabling professionals to conduct complex statistical analyses, create data visualisations, and build machine learning models. In web development, Python powers the backend infrastructure, managing data exchange, database interactions, and security. It excels in automation and scripting, allowing users to streamline repetitive tasks and processes efficiently. It also contributes significantly to software development, aiding in build control, bug tracking, and automated testing tasks.

Python as a part of arculus’ tech stack

Python has also been crucial to the arculus tech stack since the company started developing its fleet management software. Darshan explains the reason:

"The programming language selection is mainly done by considering the problem at hand and opting for the best-suited language. For applications that require high performance and efficiency, languages like C, C++, and Rust might be good candidates. Suppose the application focuses on scientific domain problems like Machine Learning, Artificial Intelligence, and Data Science. In that case, Python is a good candidate due to its popularity and the vast amount of existing libraries and applications for said domains."

As the arculus solution portfolio involves a mix of domains, use cases, and scopes, our tech stack is also a complex blend of different languages. “Factors like performance, efficiency, problem domain, time frame, and deployment platform played a vital role in crafting our tech stack,” clarifies Darshan.

So, where exactly do we use Python?

Python and Rust are the two main forces behind our fleet manager. “We use Rust for its safety, efficiency and performance, so that we can coordinate a large number of robots safely and efficiently. At the same time, Python helps us build tools, algorithms and extensions quickly and with ease. It also helps us perform data analysis on our systems for identifying bottlenecks and evaluating performance and behaviour characteristics to serve our customers better”, reveals Darshan.

Further languages in the arculus tech stack include C++, Javascript and Typescript. “The software running on the arculees, which allows them to efficiently plan paths within a given environment, is primarily written in C++, whereas Javascript and Typescript are used to build our end-user interfaces, which allow the users to interact with the robots and fleet management system,” he concludes.

TLDR.py

In summary, Python is a versatile and widely embraced programming language. It is exemplified by its rapid prototyping, user-friendly nature, robust community, and diverse applications. However, it comes with inherent limitations, including performance constraints and type safety challenges. Darshan Patel's insights from his experience at arculus, highlight Python's crucial role in the company's tech stack. Despite its challenges, Python remains a powerful tool in the arsenal of developers worldwide, shaping the landscape of software development across various domains.

Even non-techies have probably heard of popular programming languages like Java, C++ or Python. However, a new language has been stirring the programming world in recent years. And it might well be on its way to becoming as mainstream as its counterparts: Rust. In this blog post, software developer Andy Brinkmeyer sheds some light on Rust’s benefits, technicalities, and recent implementation in the arculus tech stack.

A Brief Story of Rust

A programmer gets frustrated with a piece of tech. They get home, sit on their computer and try to solve it. This is the origin and story of several software projects and it’s no different with Rust.

In 2006, Graydon Hoare, a Mozilla programmer, was forced to take the stairs to his 21st-floor Vancouver apartment after the elevator software crashed. He knew that such crashes are often caused by software written in C++ or C, which make it easier to introduce memory bugs. And so when Hoare finally got to his apartment, he opened his laptop and began designing a new programming language that would make it possible to write efficient code with improved memory safety. And the story of Rust began.

Seventeen years later, Rust has become one of the most popular languages on the planet. There are 2.8 million Rust developers around the globe, and the programming question-answer website Stack Overflow elected Rust as the most loved language for seven years in a row. Its economic relevance also can’t be questioned. Companies like Microsoft, Amazon, Meta, Discord, and Dropbox have openly talked about how Rust helped improve their system’s performance. And arculus is proud to join the group.

fn main() {
    println!("Hello, world!");
}

Example of "Hello, world!" code in Rust

What makes Rust so popular?

The short answer is that Rust addresses common pain points present in other languages while minimising any downsides. For that, it counts on a few main advantages, namely:

• memory safety
• security
• strong community
• faster development

Here is a closer look at what each of them means:

Memory Safety

This feature refers to Rust’s ability to pre-emptively avoid memory-related errors. They often lead to crashes, vulnerabilities, and unstable software behaviour. Unlike C and C++, where manual memory management can cause issues like buffer overflows and null pointer dereferences, Rust relies on three key concepts to ensure memory safety:

1. Ownership: Each value has a single owner, making it explicit who is responsible for managing the underlying memory.
2. Borrowing: Values can be accessed through references without owning them, which is called borrowing. Strict rules are applied here to ensure memory safety.
3. Lifetimes: Ensure that references are not used after the data they point to has been deallocated, preventing references to invalid memory.

As arculus developer Andy Brinkmeyer explains, the Rust compiler enforces these rules at compile time. “This prevents most memory-related bugs, which is great”, he explains. The result is more robust and safe software. That's because in other languages, programmers need to manually ensure compliance with memory safety rules.

Security

Due to memory safety issues being responsible for a major portion of reported vulnerabilities in systems, Rust's ability to eliminate these issues significantly increases cyber security.

Strong community

Rust takes pride in having a “community-driven development process where most decisions are made through open discussion and consensus”. The “Rustaceans”, as the active members of the community like to call themselves, constantly create new documentation, resources and even libraries. This makes the experience of Rust fully collaborative and interactive for developers of all levels.

Faster development

Rust enables faster programming through its combination of memory-safety and expressive syntax. By catching many common coding errors at compile time, the language reduces debugging time, ultimately accelerating the development cycle.

Rust core features

Andy explains that Rust shares many similarities with C++ since both are "statically typed, compiled languages without a garbage collector". Nonetheless, Rust's popularity comes from some of its unique features. Here is an overview of some of the most prominent ones:

Zero-cost abstractions

As Andy explains, “Abstracting away complicated logic and behaviour is one of the ways we make our software usable. Rust has this guarantee that abstracting away all this complicated logic for data types, does not incur extra cost on your compiled program”. In other words, zero-cost abstractions ensure that using convenient and expressive programming constructs, such as iterators, does not result in slower or less efficient code.

Concurrency and parallelism

Managing tasks simultaneously (concurrency) and utilising multiple processors to speed these tasks up (parallelism) are crucial aspects of modern programming. Still, handling them can be complicated and error-prone. Rust, however, makes both processes easier and more manageable. It does this by ensuring that when multiple tasks work with the same data, they can't inadvertently interfere with each other.

Andy explains that Rust makes working with concurrent and parallel code safer, through its ownership and type system. “Since a value can only have a single owner, it is impossible for two threads to own it at the same time. The type system complements this by marking if types are safe to share between threads, through borrowing and safe to send between threads by transferring ownership”, he elaborates. In other words, Rust prevents many concurrency and parallelism errors at compile time, using the same mechanisms it uses for memory safety.

use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("Here's a vector: {:?}", v);
});
handle.join().unwrap();
}

Code snippet showcasing how to move ownership into a new thread. Source: Rust book

Pattern matching

Pattern matching is a technique used to compare data structures against predefined templates and execute specific code based on the matched pattern. It simplifies decision-making by allowing developers to handle different conditions in a structured and expressive manner. Patterns can be as simple as matching specific values. Or as complex as matching the structure of data types like enums or structs.

What sets Rust apart in this regard is its commitment to code safety. Its strong type system ensures that pattern matching covers all possible cases and reduces the risk of runtime errors. Rust’s concise and expressive syntax makes code more readable. It also provides features like pattern destructuring, automatic variable referencing, and customisation options.

Cargo

Cargo is Rust’s build system and package manager. What makes it a notable aspect of Rust is its capacity to handle many tasks. Some examples are building code, downloading the libraries on which the code is dependent, and building such libraries – also called dependencies.

“With Cargo, a Rust project centres around a single configuration file, where you define the properties like name, version, and dependencies. Cargo then handles the essential tasks, like setting up the project, compiling code, and linking build artefacts. In practice, using Cargo often boils down to running a single command like 'cargo run,' which simplifies the entire development process."

Andy Brinkmeyer

Rust at arculus

The Rust programming language has proven to be a highly versatile tool, with widespread applications across various fields. The most prominent ones include Operating Systems (OS), Kernel programming, embedded systems, and cloud infrastructure. And while its numerous advantages make the number of potential Rust applications grow steadily, there is one field in which it still falls short: robotics.

“In robotics, tasks such as perception, path planning, and localisation involve complex algorithms. These algorithms have evolved over a long time through collaboration between academia and industry, and they are typically implemented in libraries”, clarifies Andy. “Many of these essential libraries are intertwined with C++, creating a dependency ecosystem that reinforces its use. Transitioning from this well-established field, where everything you need is in a single language, to Rust can be a significant step. While Rust is gaining traction in robotics, C++ still holds the number one position in this field for now", he concludes.

So why do we use Rust at arculus?

While using Rust in our robots is challenging right now, the language is the perfect alternative component of the tech stack that makes up our fleet software solution. “We need something with high performance that can manage multiple robots simultaneously. But we also need reliability and safety because the customers depend on us not crashing and not having errors in the code. They rely on us for the system to run indefinitely without problems. And that's why we are slowly implementing Rust”, highlights Andy.

Managing the transition

For Andy, what defines the approach to the transition process at arculus is “learning by doing”:

“Of course, people had time to prepare and study the (Rust) documentation. But we at arculus are really hands-on, in quite a literal sense – hands on the project, hands on the work. And in my opinion, contributing very early in the adapting phase to the codebase was the best way to get people up to speed. This approach combined with regular feedback by experienced Rust developers allowed us to quickly adopt it as a language and get everyone all set.”

Andy Brinkmeyer

Learning resources

With such an engaged and supportive community, Rust is arguably one of the most well-documented programming languages – and that includes learning resources. For Andy, the most useful ones can be found on the official Rust project website. “The official Rust book was for me, the perfect mix between theory and real-world examples. But I also learned a lot through the other resources on the website, like Rust by example”, he concludes.

exit()

To sum up, Rust has emerged as a robust and adaptable programming language that is gaining recognition across various industries. Its origins trace back to addressing the need for safer and more efficient software, a mission it continues to excel at. From memory safety to security, a reliable community, and enhanced development speed, the language offers a compelling package for software developers.

As the arculus team integrates Rust into the tech stack, it leverages the language's exceptional qualities to ensure high performance, reliability, and safety in our software solutions. While the transition is ongoing, we are committed to the "learn by doing" approach, harnessing the wealth of resources the Rust community provides. Rust's journey at arculus reflects its evolution as a language that meets and exceeds modern software development's demands.