DEV Community: Munir Abdullahi

Rust Vs. Other Programming Languages: What Sets Rust Apart?

Munir Abdullahi — Fri, 14 Jun 2024 16:02:00 +0000

Introduction

The rapid emergence of different programming languages in the technology landscape may affect the programming language/tool choice while building a software product. Despite this, some programming languages stand out, and Rust is one of them. Rust is a systems language designed to solve challenging software problems.

Since its announcement in 2010, Rust has witnessed tremendous growth. Its modern syntax and thriving community are quite attractive, so it is no wonder it was referred to as the "most loved" programming language in the 2023 StackOverflow Developer's survey.

This article covers an overview of Rust programming language. It starts with its historical background. Then, it explores its fantastic and unique features, application areas, and how it compares to other programming languages. We will see why companies love Rust and how they use it.

Historical Background of Rust and its Rise in Popularity

It started when the creator, Graydon Hoare, had an elevator-crashing experience and realized this was a problem of poor memory management. So, in 2006, Hoare designed Rust as a side project to handle pitfalls such as memory management in C and C++ while offering type safety, high performance, and concurrency. Mozilla further sponsored the language and released it in 2010.

photo from Google Trends showing Rust's internet trend over the past five years

In 2012, Rust underwent a significant evolution, marked by the introduction of versions 0.2 and 0.3. These versions brought with them a host of new features, including classes, polymorphism, and destructors, which significantly enhanced the language's functionality. This evolution was not a solitary effort, but a testament to the collective progress of the Rust community.
In its early days, the Rust team gradually consolidated several memory management techniques. However, in 2013, the team removed the garbage collector and maintained ownership rules.
The team released the first stable version, version 1.0, in 2015 after several versions.

2017 saw the integration of Rust components into Firefox 57. In 2020, the massive layoff at Mozilla raised concerns for the future of Rust. However, the Rust Foundation was formed, and its establishment was announced in 2021. Some companies, like AWS, Google, Microsoft, etc., founded the foundation and took ownership of the associated domain names.

photo from 2023 StackOverflow Survey showing Rust as the most admired language with 84.66%

Features of Rust

Concurrency and Parallelism
Concurrency is the ability for different parts of a program to run independently. The Rust concurrency model is called the fearless concurrency. It enables developers to write bug-free and easy-to-refactor code.
Threading is a method for implementing concurrency in Rust. It is a core feature of the concurrency model. With threads, tasks are subdivided and run in multiple processes simultaneously.
The std::thread module in Rust is a powerful resource for creating and managing threads. It provides functions like 'spawn ', which not only create a thread but also execute a specific function within that thread, offering developers a high level of control over their concurrent processes.
Parallelism improves performance and efficiency in the codebase. Multiple CPU cores execute processes. Rayon is a library that implements parallelism in Rust.
Performance and Efficiency
Zero-cost abstraction in Rust achieves good performance and efficiency. Abstractions such as closures and iterators prevent runtime overhead. Features like concurrency and parallelism also contribute to the overall performance.
Memory Safety and Ownership
A program manages memory through memory safety to prevent errors. The ownership system ensures memory safety in Rust and dictates memory management in the program. Every value in the program has an owner. When the current context is no longer accessible to the owner, the memory associated with the value is deallocated or freed.
Strong Package Manager with Cargo
Cargo is Rust's package manager, making handling package dependencies and distribution easier. Package versions and dependencies can be added and specified when working on a project. Cargo also offers a range of commands to automate tasks such as running tests and compiling code.
Community and Documentation
The Rust community commits to welcoming and supporting new members. It has various platforms and forums where users can communicate and gain support. Since Rust is an open-source project, community members actively contribute to and maintain it.
Industry experts organize events to enhance learning and stay up-to-date with new versions. The community is friendly and inclusive, making it safe for everyone of different diversities to participate and engage.
The Rust official documentation is a robust and well-detailed guide for the language, including its syntax and libraries. The following are different sections of the documentation:
Modern and Clean Syntax
Rust is known for its modern and clean syntax, which balances complexity and readability. Its syntax offers closure and pattern matching, which help make complex code readable.
Safety and Reliability
Safety and reliability are core principles of Rust in its design and syntax. This feature is a result of the removal of the garbage collector.

How Does Rust Compare to other Programming Languages

This section compares Rust with other programming languages, discussing its strengths and weaknesses in areas of software development.

photo from 2023 StackOverFlow Survey showing Rust as the 14th most popular language with 13.05%

Rust Vs. Python

When is Rust better than Python?

Concurrency
Due to its ownership feature, Rust is more efficient in concurrent programming. It helps developers write multi-threaded programs without introducing bugs. Python is limited in concurrent programming due to the Global Interpreter Lock (GIL). Thus, Rust does concurrent programming better than Python.
Performance
Rust is a system programming language suitable for high-performance applications. In some cases, It can run twice as well as Python. Rust's memory management feature also adds to its performance. Python is an interpreted language that runs processes slower due to compilation.
Security
The Rust language is designed to provide optimal security for applications. Rust’s programs are statically typed, detecting errors before compilation. Memory safety also enhances the security of the code.
Python, on the other hand, interprets its program just before execution, which can lead to runtime errors and potential vulnerabilities. This means that developers using Python must be diligent in managing memory, a task that can consume both time and resources.
Garbage collection
The Rust ownership system eliminates garbage collection. Python uses garbage collection to check for unused memory and manage it. However, this may cause hitches in its performance.

When is Python better than Rust?

Learning Curve
Python is very beginner-friendly. The code structure is more readable, and the syntax is simple. Developers at all levels can learn quickly. Complex features, such as concurrency, make Rust’s learning curve steeper.
Flexibility
Python is applicable in many areas of technology. It supports several domains, like web development, machine learning, etc., with many libraries. While Rust is great for system programming, it offers less flexibility than Python.
Documentation
Due to its longevity, Python's documentation is extensive, user-friendly, and easier to understand. Rust's documentation is comprehensive but more technical and not user-friendly.
Community
Python has a larger community. It is an open-source project with a wide range of domains and applications. Rust has a growing community with active contributors and users. However, it is considered smaller than that of Python.

Rust Vs. JavaScript

When is Rust better than JavaScript

Memory Management
One key difference between Rust and JavaScript is how they handle memory. JavaScript uses garbage collection to free up memory automatically. Rust uses ownership system rules to deallocate memory, resulting in better performance and minimal errors.
Type System and Compiled-time Checks
In Rust, developers can define variables alongside their data type. This feature ensures security and error handling before program execution. JavaScript is a dynamically typed programming language whose variables can be any data type. While this makes JavaScript flexible, it may lead to runtime errors.
Performance
Rust outperforms JavaScript. Rust programs are highly optimized and suitable for heavy tasks. JavaScript is applicable for web-based applications.
Error Handling
JavaScript uses the try-catch technique to catch errors at runtime. While this guarantees error handling, unhandled exceptions may occur at runtime and cause breaks in the code. Rust uses the result-match technique to catch errors before code execution.

When is JavaScript better than Rust

Ecosystem and Community
Due to its longevity, JavaScript has a larger ecosystem and community. It has a range of active frameworks and libraries, and it is easy to find solutions to problems in the community. Rust has a smaller and growing community, although it strives to help new learners.
Rapid Prototyping
JavaScript’s dynamic typing feature and flexibility make writing and testing code easy, especially for small projects. Rust is statically typed and can slow down the prototyping process.
Cross-platform Development
JavaScript versatility allows developers to build applications across different operating systems and environments with minimal adjustment. While Rust has cross-platform functionality, it doesn’t surpass JavaScript.
Web Development
JavaScript is the language of the web. No programming language comes close to this functionality. Rust also applies in web development but has problems writing async request handlers.

Rust Vs. C++

When is Rust better than C++

Memory Safety
Rust ensures efficient memory safety functionality through its ownership system. C++ lacks memory safety, thus making it vulnerable to memory-related errors. In C++, developers need to manage memory by themselves.
Concurrency
Developers achieve concurrency in Rust without synchronization bugs. Although C++ offers concurrent programming through libraries like threads, it lacks Rust safety features. Manual synchronization primitives can provide safety in C++, but they are error-prone.
Modern Syntax
Rust offers a more modern and expressive syntax compared to C++, which has a more complex syntax. Rust has a smaller feature set compared to C++, which enhances a developer’s productivity. C++ may offer flexibility due to its numerous features, but it also increases complexity.
Ecosystem and Community
The vibrant and growing Rust community is devoted to improving code quality. A growing ecosystem of libraries and frameworks makes development easier.

When is C++ better than Rust

Fine-grained Control
C++ allows developers to manage system memory in their own way. The program's resources are free to use. Based on the specific performance target, developers can implement optimizations and fine-tuning.
Large Standard Library
C++ has an extensive list of standard libraries packed with functionality to solve various tasks. These libraries provide built-in components to execute tasks such as data structures, algorithms, and input/output operations. Developers can then build high-performance applications with the aid of these libraries.
Legacy Systems
C++ is compatible with legacy systems, especially since it is an extension of C. Thus, developers can easily integrate it into legacy codebases, easing migration processes. Because Rust is a newer language, incorporating it into legacy codebases might pose a challenge.
Learning Curve
C++ shares similarities with some Object-Oriented Programming (OOP) languages, such as C and Java. Developers with experience with OOP languages can quickly learn C++. In addition, there are abundant learning resources and tutorials to aid learning.

Applications of Rust

Rust is applicable in various fields due to its unique and dominant features. This section explores the areas where Rust is applicable.

Systems Development Rust's efficiency and memory safety make it a top language for developing operating systems. Since safety in modern applications is essential to prevent cyber attacks, companies and developers tend to use Rust in systems programming.
Web Development While some languages are popular in web development, Rust is also applicable due to its high performance and safety. Rust WebAssembly enables developers to compile Rust code into a binary format and execute it in the browser.
Game Development Aside from C# and C++, Rust is also a language developers use in game development. Game engines like Amethyst offer efficiency and faster runtimes. Since C++ is similar to Rust, it is easier for C++ developers to expand their knowledge and use Rust in development.
Embedded System Rust is beginning to dominate the field of embedded systems. Memory management is a common challenge in embedded systems, making Rust a better technology for programming embedded systems.
Blockchain and Cryptography Blockchain technology requires cryptographic operations and demands high performance and security. Blockchain projects such as Solana and Parity Ethereum have adopted Rust in their technology.
Data science and Machine Learning Rust is considered the next big thing in data science and machine learning. While there are popular languages like Python and R, Rust’s outstanding efficiency and ownership system make it a good option for handling large datasets.

Popular Companies that use Rust

Companies worldwide have found Rust programming language applicable to their products, and developers love the language as it increases productivity. This section explores the top applications that use Rust, how top companies use Rust, and why these companies like Rust.

Popular companies that use Rust

Top Applications that Use Rust

Dropbox
Dropbox is a collaboration and cloud storage platform that uses Rust to improve its infrastructure reliability and performance. Dropbox Capture, a visual communication tool, has benefited from Rust in ways such as better error handling. Currently, Dropbox uses Rust in the core file-storage system that serves over 500 million users.
Figma
Figma is a web-based design collaborative tool that utilizes Rust in its backend infrastructure. The team at Figma has witnessed incredible improvements in their server-side performance. Figma rewrote their multiplayer server in Rust using TypeScript.
Discord
The Discord team switched from Go to Rust when they discovered that Go always forced garbage collection. Today, they use Rust on the client side for the video encoding pipeline and Elixer NIFS on the server side. Also, Discord switched from Go to Rust in their Read State service.
Cloudflare
Cloudflare is a leading internet service security provider. The Cloudflare application uses Rust in DDoS detection. The team also developed an open-source Rust framework called Pingora that builds services for traffic on Cloudflare. Cloudflare's Data Loss Prevention team uses Rust in the data and control plane.

Big companies that use Rust

Amazon
Amazon is an e-commerce company that owns Amazon Web Services (AWS) but uses AWS independently by providing cloud computing services to individuals and companies. Firecracker was Amazon's first notable product implementation using Rust. They also use Rust to deliver services such as Amazon Simple Storage Service (Amazon S3), Amazon Elastic Compute Cloud (Amazon EC2), and Amazon CloudFront.
Amazon's commitment to Rust is unwavering. They recognize its potential to help them build and deliver robust services faster. This commitment is further demonstrated by their sponsorship of the Rust open-source project since 2019.
Microsoft
Microsoft is a founding member of Rust’s foundation. The company has since dedicated itself to the development and success of the programming language. Microsoft built its core Windows libraries with Rust and plans to write future projects with Rust. Microsoft’s Windows 11 boots with Rust and passes Graphic Device Interface (GDI) tests. Microsoft may not be rewriting Windows with Rust soon.
The Mozilla developer team built the Firefox CSS engine, Stylo, with Rust. Rust also occupies 11.4% of the code in Firefox and other languages. Mozilla was the first founding member of the Rust project. The company’s commitment to seeing the language grow to success is a priority. Rust is considered one of Mozilla’s main contributions to the industry.
Meta
Rust is a primarily supported server-side language in Meta for its ability to provide performance-sensitive backend services. Meta-child company Facebook has since adopted Rust and became one of the members of the Rust Foundation. The early use of Rust on Facebook is where the team rewrote the Mononoke.

Why do companies like Rust

Efficient Memory Management and Safety Companies like Rust's memory management. It improves software application performance and effectively manages memory. Due to the low risk of memory-related issues, companies can save resources by implementing costly maintenance. Memory safety is guaranteed, and sensitive data is also protected.
Thriving Community and Documentation Developers contribute to and support the language daily by building frameworks and tools. These tools reduce development time and enhance productivity. Developers can easily find solutions to bugs and learn the language through documentation.
Cybersecurity Capabilities Rust's memory safety helps prevent malicious attacks. Reducing security attacks and data theft ensures the company's credibility.
Developer Productivity Rust-language features aid in reducing debugging time. Improvements occur in the development process and development time. Product quality is improved, and product versions can be released quickly for software applications.

Conclusion

With the rising number of programming languages, choosing the right one for the task is necessary. Rust programming language has proven to be an efficient and reliable tool. Its distinction from other languages sets it apart, making it the most admired language eight times in a row.

This article has explored Rust as a programming language, starting with how it made it to the scene and how companies find it appealing. We learned about its unique features. We have also looked at Rust Vs. JavaScript, Rust Vs. Python, and Rust Vs. C++ how it compares to other languages, and its various applications.

We have seen how Rust’s ownership system and performance, amongst other top features, have set it above many programming languages. Rust is a top pick to build high-performance applications; however, it may not solve every software problem. However, It will continue to pave the way to breaking boundaries in software development.

A Guide to Passing Data Using Props in React

Munir Abdullahi — Fri, 08 Sep 2023 09:21:18 +0000

Introduction

The React framework is very popular for this is its ability to build dynamic user interfaces. In your journey of learning React, you will encounter the concept of Components and how they communicate. Think of components as the foundation on which react user interfaces are built.

In this tutorial, you will learn about:

React and its Component.
The concept of props and data transfers between React Components.
Effective components communicate using props.

All code examples can be accessed here

Prerequisites.

Basic knowledge of JavaScript ES6 syntax.
Basic command line knowledge.
Basic knowledge of HTML.

Nice to have:

Basic React knowledge.

React and Its Components

What is React?

React is an open-source front-end JavaScript framework containing reusable functions used for creating dynamic user interfaces. Created by Facebook in 2013, it has become the most widely-used front-end framework.

What is a React Component?

React components are isolated blocks of functions used to implement specific functionalities and build user interfaces. To achieve the dynamic state required, they need to receive data to interact with themselves. They can be created and updated by the developer. Updating the component model updates the user browser. Think of a component model as a tree with a component at the top. The component at the top is called the root/parent component.

The diagram above represents a simple Todo list component tree structure.

The App component at the top represents the root/parent component. It oversees everything. It contains two children components: Add Item and Todo Items.

The Add Item contains two components: Text-Input- a text field where you can write a new item, and Add Button - a button that adds what you have written to your Todo list.

The Todo items also contain two components. The components are the Todo list items added. Note that it could be more than two in this case.

When you click on a button, events happen at a component and they can affect other parts of the codebase. For instance, when the Add Button is clicked, it tells the App component to add a new task. The text entered is sent to the Todo Items through the App component. This action adds a new item, and then the UI updates as the component changes.

In conclusion, React components are building blocks that help us create dynamic websites and applications. They work together to ensure the application displays and functions well.

Why do we need to Pass Data between Components?

React relies majorly on its component model. But how will these components be reactive to each other? For instance, from the example above, how will the Add Button component know that data should be sent to the Todo Items component when an event is triggered? Here is where the passing of data comes in. It is a crucial aspect of building efficient and dynamic user interfaces. It enables you to build complex UIs that can be made simpler by creating reusable and modular components.

Understanding Props in React

To use Props effectively, it is important to understand how it works, including how it is used to pass data between components.

The Concept of props in React

Props(properties) is a technique of passing data from one component to another. With props, the parent component can share data with the child component. The child component then renders this data to the UI.

Props are immutable. When passed to the child component, they cant be updated but can still be accessed and used. This attribute helps maintain a clear separation between parent and child components.

How do props fit into the data flow in React?

In React, data flows in a unidirectional manner. It travels from the parent component to the child component only. Here is a step-by-step process of how data flows in React components.

Data flow starts from the parent component. This data can be from an API
The data in the parent component is transferred to its child component by props.
The child component receives, accesses, and uses the data. Here is where the data consumption takes place. The data is rendered as UI elements or for other functions.
The data is then dynamically rendered as content on the UI. It is interpolated with Javascript XML(JSX) to display the data as an output on the screen.
Data changes in the parent component result in new data inflow to the child component, making the application re-render.
Since data flow is unidirectional, the flow stops at the child component.

Transferring Data from Parent to Child Component

As discussed, passing data between components is an essential feature in React. To master it, start by making a simple React application with the Vite tool in your terminal and type in npm create vite@latest reactProps -- --template react.

Navigate to the directory with this command cd reactProps .

Next is to install all the dependencies by executing this command npm install .

The file tree should look like this.

Creating Components

Firstly, open the App.jsx file in the src folder and replace the code there with the one below. All code examples will run on this file.

src/App.jsx

const App = () => {
  return (
    <div>
      <p>Hello world</p>
    </div>
  )
}
export default App

This code defines a functional React component named App. This component renders a div containing an h1 element with the text Hello world and a p element with the text I am a React Component. To make it available in other parts of the codebase, the file must be exported.

In the src folder's main.jsx file, the following code block imports the App component from the App.jsx file and renders the content of the App component in the div element with the id value of root defined in the public/index.html.

import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App.jsx'

ReactDOM.createRoot(document.getElementById('root')).render(
  <React.StrictMode>
    <App />
  </React.StrictMode>,
)

Here is what the code outputs.

You can remove App.css and index.css files from the project folder since all code examples are executed on the src/App.jsx file.

Passing Props to a Component

To begin, import propTypes from the 'prop-types' library. This library ensures that the correct type of props are passed to a component.

Afterward, build a component named Message that will accept a prop named greeting and display a message within it. Using the return statement, tell the component what to render.

Finally, indicate that the greeting component can accept any React node and make it a requirement when employing the Message component. A React node can be a variety of things, such as a string, number, JSX, and more.

src/App.jsx

import propTypes from 'prop-types'

const Message = (props) => {
  return (
    <div>
      <p>{props.greeting}</p>
    </div>
  )
}

Message.propTypes = {
  greeting: propTypes.node.isRequired
}

In the src/App.jsx file, replace the code inside the div element with the code below in the App component.

<Message greeting="Greetings from the Child Component" />

Here is what the code outputs.

Destructuring Props Object

The JavaScript ES6 destructuring syntax can extract specific props from the props object. Here, the name and age props are directly removed.

src/App.jsx

const Profiles = ({ name, age }) => {
  return (
    <div>
      <p>
        Hello {name}. Your age is {age}
      </p>
    </div>
  )
}

Profiles.propTypes = {
  name: propTypes.node.isRequired,
  age: propTypes.node.isRequired
}

Replace the code inside the div element in the parent component with the code below.

src/App.jsx

<Profiles name={name} age={age} />

Setting Default Value for a Prop

Default values can be set to props in the child component, providing a fallback when nothing is specified. For instance, in the Profile component, you can set a default value of "John Doe" to the name prop. If not defined, the name prop will assume the value of "John Doe". Check out the code below for an example of how this works.

src/App.jsx

const Profiles = ({ name = 'John Doe', age }) => { 
}

Propagate Props with JSX Spread Syntax

JSX spread syntax is a technique for passing properties from parent and child components. This involves the parent component collecting and spreading the properties to the child component. You will examine this technique in the example below.

Firstly, import the PropTypes module from the prop-types package. It defines the expected type of prop for the component.

Then create a Component named Avatar that receives a prop and displays information about a person. The received prop object is broken down into the person prop. Then, the div element in the component gets displayed on the screen.

Finally, for this component, assign a propTypes property to it. This property confirms the incoming person prop. The person prop can be of various types and is required when the component is being utilized.

src/App.jsx

import PropTypes from "prop-types"

const Avatar = (props) => {
  const { person } = props

  return (
    <div>
      <p>Name: {person.name}</p>
      <p>Age: {person.age}</p>
      <p>Occupation: {person.occupation}</p>
      <p>Country: {person.country}</p>
    </div>
  )
}

Avatar.propTypes = {
  person: PropTypes.node.isRequired,
}

Create a new component called Profile. This component will receive the prop and display the Avatar component using the spread syntax instead of passing individual items to be displayed separately.

src/App.jsx

function Profile(props) {
  return (
    <div>
      <Avatar {...props} />
    </div>
  )
}

To complete this setup, it is necessary to create the final component named App. This component defines an object that includes the avatarProps object with multiple properties. The App component displays the Profile component that accepts the avatarProps through the spread syntax.

Always remember to export the parent component to ensure proper functionality.

export default App

Here is what the code outputs.

In the example above, the spread syntax was used twice. This syntax allows all props received to be passed from the Profile component to the Avatar Component at once, eliminating the need to list them individually.

The avatarProps object is passed to the Profile component using the spread syntax with its properties being transferred as separate props to the Profile component. This approach offers the benefit of forwarding all props from the top component (i.e., the App component) to the Avatar component.

Passing JSX as Children Prop

To render JSX content within a component, JSX is used as a child prop. It is placed between the opening and closing tags of the component, and it is treated as dynamic content by the component's rendering logic.

To implement this, create a component named Modalthat uses the children prop to receive and render JSX content passed between its tags. Note that the children must be provided when using the Modal component. It is necessary to import PropTypes for this purpose.

src/App.jsx

import PropTypes from "prop-types"

const Modal = ({ children }) => {
  return <div>{children}</div>
}

Modal.propTypes = {
  children: PropTypes.node.isRequired,
}

The Modal component is rendered by the App component with JSX elements defined between its opening and closing tags.

src/App.jsx

const App = () => {
  return (
    <div>
      <Modal>
        <h2>Welcome to the Modal!</h2>
        <p>This is some content within the modal.</p>
      </Modal>
    </div>
  )
}

export default App

Here is what the code outputs.

Conclusion.

This guide introduced you to the world of React Components and the role they play in displaying dynamic user interfaces. You were introduced to the world of props and clarified the concept behind it.

Understanding how info and data are passed between parent and child components will come in handy in your React mastering journey. It gets more intricate than this going forward, so brace yourselves.

The good news is that it builds upon the foundation already treated in this guide. What would you like to learn about next? Let me know in the comments.

Found this article helpful?

Feel free to find me around the web for questions and clarifications.

Thanks for reading to the end.

Career Advice

Munir Abdullahi — Wed, 02 Mar 2022 15:50:18 +0000

Hello everyone. I just got enrolled in a software engineering school for a one-year diploma. I initially chose cloud engineering but I am having a second thought on it. The school also offers frontend and backend. What are the job opportunities in cloud engineering and easy is it for me to get a job in the cloud? Also is it mandatory I get certified in one of the cloud providers like aws?

cloudengineering #frontend #tech