Lesson 15: Async Programming - The Tokio Framework

Introduction

Overview of Asynchronous Programming in Rust

Asynchronous programming is a paradigm that allows for non-blocking operations, enabling programs to perform multiple tasks concurrently. In Rust, this is achieved through the async and .await syntax, introduced in Rust 1.39. This feature allows functions to be defined as asynchronous (async fn), returning a Future. A Future is a core trait representing a value that may not be immediately available. To efficiently manage these asynchronous operations, Rust employs executors, which are responsible for polling futures to completion.

The Significance of Tokio in Rust's Async Ecosystem

Tokio stands out as a prominent runtime in Rust's async ecosystem, providing a multi-threaded, work-stealing scheduler. It is designed to efficiently run asynchronous tasks, I/O operations, and timers. Tokio is not just an executor; it's a comprehensive framework offering utilities to create both simple and complex network applications. It includes:

An I/O driver built on top of mio for event-driven, non-blocking I/O.
Utilities for asynchronous networking and inter-task communication.
Time-based functionalities, such as delays and intervals.

Tokio's significance lies in its ability to leverage Rust's safety and performance traits, offering a robust platform for developing high-performance asynchronous applications. It's widely used in web servers, database clients, and various network services, illustrating its versatility and reliability in handling asynchronous operations.

In the following sections, we will delve deeper into Tokio's components, its usage patterns, and practical code examples to demonstrate its capabilities in real-world scenarios.

1. Tokio's Core Components

Tasks

Definition, Importance, and Tokio's Approach to Task Management
Tasks in Tokio are analogous to lightweight threads, executing async blocks of code. They enable concurrent, non-blocking operations, essential in I/O-bound applications. In Tokio, tasks are built on Rust's Future trait and are scheduled to run when the resources they await are ready.

Example: Creating and Spawning a Task in Tokio

#[tokio::main]
async fn main() {
    tokio::spawn(async {
        // Perform some asynchronous work
        println!("Task is running");
    });

    // Other code can run concurrently here
}

Task Scheduling and Execution in Tokio's Architecture
Tokio employs a work-stealing scheduler to distribute tasks across threads efficiently.

Example: Work-Stealing in Action

#![allow(unused)]
fn main() {
// This code example is conceptual and for illustrative purposes
// It demonstrates the idea of work-stealing, not actual Tokio API usage.
tokio::spawn(async { /* Task 1 */ });
tokio::spawn(async { /* Task 2 */ });

// If one thread becomes idle, it can steal and execute tasks from others.
}

Reactors

The Concept of a Reactor in Async Programming
Reactors monitor I/O resources for readiness and notify relevant tasks. This is key for efficient I/O handling.

How Tokio Implements an Event-Driven Model with Reactors
Tokio's reactors use OS-level events to manage I/O readiness notifications.

Example: Using a reactor in Tokio (File)r

// Tokio's reactor runs implicitly in the background when using the tokio runtime.
#[tokio::main]
async fn main() {
    // When performing async I/O operations here, Tokio's reactor is engaged.
    let data = tokio::fs::read("some_file.txt").await.unwrap();
    println!("Read data: {:?}", data);
}

Executors

Executors in Tokio Explained
Executors drive tasks to completion by polling them.

Comparison of Threaded vs Current Thread Executors in Tokio

Multi-Threaded Executors: Ideal for parallel task execution.
Current Thread Executors: Better for lighter workloads and more control.

Example: Multi-Threaded Executor

#[tokio::main] // Defaults to a multi-threaded executor
async fn main() {
    // Tasks spawned here can run on different threads
}

Example: Current Thread Executor

#[tokio::main(flavor = "current_thread")]
async fn main() {
    // Tasks spawned here will run on the current thread
}

If you want to configure how much threads you want your executor to have, you can change it with the attribute:

#![allow(unused)]
fn main() {
#[tokio::main(flavor = "multi_thread", worker_threads = 10)]
}

You can also create an executor manually:

fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async {
            println!("Hello world");
        })
}

In the following sections, we will explore more intricate functionalities and advanced usage scenarios within the Tokio framework.

2. Tokio's IO Library

Async Read and Write

Synchronous vs Asynchronous IO: Differences and Implications
In synchronous IO, operations like reading from or writing to a file block the executing thread until the operation completes. This can be inefficient, especially in IO-bound applications where such operations are frequent. In contrast, asynchronous IO operations allow the thread to perform other tasks while waiting for IO operations to complete, significantly improving resource utilization and throughput.

Example: Synchronous Read (Standard Rust)

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::Read;

let mut file = File::open("some_file.txt").unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
// The thread is blocked until the file is fully read.
}

Example: Asynchronous Read (Tokio)

use tokio::io::AsyncReadExt;

#[tokio::main]
async fn main() {
    let mut file = tokio::fs::File::open("some_file.txt").await.unwrap();
    let mut contents = Vec::new();
    file.read_to_end(&mut contents).await.unwrap();
    // Other async operations can run while waiting for the file to be read.
}

Building Async Read and Write Operations Using Tokio
Tokio provides async versions of standard read and write operations, allowing for non-blocking IO in async applications.

Example: Asynchronous Write (Tokio)

use tokio::io::AsyncWriteExt;

#[tokio::main]
async fn main() {
    let mut file = tokio::fs::File::create("output.txt").await.unwrap();
    file.write_all(b"Hello, world!").await.unwrap();
    // The file write operation is non-blocking.
}

Async Networking

Creating Async TCP/UDP Servers and Clients
Tokio excels in building high-performance network applications with support for both TCP and UDP protocols. Asynchronous networking allows handling many connections simultaneously without the overhead of thread-per-connection.

Example: Asynchronous TCP Server (Tokio)

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    loop {
        let (mut socket, _) = listener.accept().await.unwrap();
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(_) => return,
                };
                if socket.write_all(&buf[0..n]).await.is_err() {
                    return;
                }
            }
        });
    }
}

Managing Concurrent Connections Effectively
Tokio's asynchronous model is particularly beneficial for managing numerous concurrent network connections. By spawning tasks for each connection, the server can handle multiple connections concurrently without blocking.

Example: Handling Multiple TCP Connections Concurrently (Tokio)

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() {
    // Bind the server to a local address
    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    println!("Server running on 127.0.0.1:8080");

    loop {
        // Accept incoming connections
        let (mut socket, addr) = match listener.accept().await {
            Ok((socket, addr)) => (socket, addr),
            Err(e) => {
                eprintln!("Failed to accept connection: {}", e);
                continue;
            }
        };
        println!("New connection from {}", addr);

        // Spawn a new task for each connection
        tokio::spawn(async move {
            let mut buffer = [0; 1024];

            // Read data from the socket
            loop {
                match socket.read(&mut buffer).await {
                    Ok(0) => {
                        // Connection was closed
                        println!("Connection closed by {}", addr);
                        return;
                    }
                    Ok(n) => {
                        // Echo the data back to the client
                        if let Err(e) = socket.write_all(&buffer[..n]).await {
                            eprintln!("Failed to write to socket: {}", e);
                            return;
                        }
                    }
                    Err(e) => {
                        eprintln!("Failed to read from socket: {}", e);
                        return;
                    }
                }
            }
        });
    }
}

Tokio's IO capabilities are integral to building efficient, scalable asynchronous applications in Rust. In the following sections, we will further explore advanced features and patterns in Tokio's async programming.

3. Tokio `select!` Macro

Understanding `select!`

The Functionality and Significance of the select! Macro
The select! macro in Tokio is a powerful tool for handling multiple asynchronous operations concurrently. It allows a program to "select" over a set of different futures, effectively waiting for the first one to complete. This is particularly useful in scenarios where you need to respond to whichever operation completes first, without blocking on each individually.

Example: Basic Usage of select!

use tokio::select;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let future1 = sleep(Duration::from_secs(5));
    let future2 = sleep(Duration::from_secs(10));

    select! {
        _ = future1 => println!("Future 1 completed first"),
        _ = future2 => println!("Future 2 completed first"),
    }
}

Practical Applications

Managing Multiple Futures and Timeouts in Async Workflows
select! is ideal for managing different futures, especially when dealing with I/O operations, timers, or any combination of asynchronous events. It's also useful for implementing timeouts for certain operations.

Example: Using select! with a Timeout

use tokio::time::{sleep, timeout, Duration};

#[tokio::main]
async fn main() {
    let long_running_future = sleep(Duration::from_secs(30));

    match timeout(Duration::from_secs(10), long_running_future).await {
        Ok(_) => println!("Operation completed within the timeout"),
        Err(_) => println!("Operation timed out"),
    }
}

Addressing Conditional Async Operations
select! can be used to handle conditional asynchronous logic, where the completion of certain tasks may depend on external or concurrent factors.

Example: Conditional Operation with select!

// Example demonstrating conditional operation based on external factors
// using `select!`.
use tokio::select;
use tokio::sync::mpsc;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);
    let timeout_duration = Duration::from_secs(5);

    // Simulate an external event sending a message
    tokio::spawn(async move {
        sleep(Duration::from_secs(2)).await;
        tx.send("Message from external event").await.unwrap();
    });

    select! {
        Some(message) = rx.recv() => {
            // Handle the message received from the channel
            println!("Received message: {}", message);
        }
        _ = sleep(timeout_duration) => {
            // Handle timeout
            println!("No message received within {} seconds; operation timed out.", timeout_duration.as_secs());
        }
    }
}

Best Practices and Patterns

Efficient and Clean Code Using select!
When using select!, it's important to structure code for clarity and efficiency. Avoid overly complex select blocks and consider breaking down complicated logic into simpler, more manageable parts.

Avoiding Common Pitfalls in Using select!
A common pitfall with select! is the accidental creation of biased selections, where one future is unintentionally given priority over others. Ensure that futures are structured in a way that avoids such biases unless explicitly intended.

Example: Another Use of select!

// Demonstrates a balanced approach in using `select!` to avoid biased selections.
use tokio::select;
use tokio::time::{sleep, Duration, Instant};

#[tokio::main]
async fn main() {
    let future1 = sleep(Duration::from_secs(3));
    let future2 = sleep(Duration::from_secs(1));
    let future3 = sleep(Duration::from_secs(2));
    let start_time = Instant::now();

    loop {
        select! {
            _ = future1 => {
                println!("Future 1 completed after {:?}", start_time.elapsed());
                break;
            }
            _ = future2 => {
                println!("Future 2 completed after {:?}", start_time.elapsed());
                break;
            }
            _ = future3 => {
                println!("Future 3 completed after {:?}", start_time.elapsed());
                break;
            }
        }
    }
}

The select! macro is a versatile tool in the Tokio toolkit, enabling complex and responsive asynchronous logic in Rust applications. The next sections will further explore advanced Tokio features and real-world application scenarios.

4. Async Database Libraries

Overview

Challenges of Traditional Blocking Database Operations
In traditional database interactions, operations like queries and transactions are blocking, meaning they hold up the execution thread until completion. This can lead to inefficiencies in resource usage, especially in applications requiring high concurrency. Blocking operations are detrimental in an asynchronous environment, as they counteract the benefits of non-blocking, concurrent execution.

Integrating `sqlx` with Tokio

Configuring an Asynchronous Database Connection
sqlx is a popular asynchronous, pure-Rust database library that integrates seamlessly with Tokio. It supports various databases like PostgreSQL, MySQL, SQLite, and more. Configuring an async database connection with sqlx involves setting up the database client with appropriate connection parameters.

Example: Async Database Connection with sqlx

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() {
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://user:password@localhost/database")
        .await
        .unwrap();

    // Use the connection pool for async database operations
}

Performing Async Queries and Managing Results
With sqlx, executing asynchronous queries and handling their results is straightforward. It leverages Rust's type system for compile-time query validation, enhancing safety and reliability.

Example: Async Query with sqlx

#![allow(unused)]
fn main() {
use sqlx::postgres::PgPool;

async fn fetch_data(pool: PgPool) {
    let rows = sqlx::query!("SELECT id, name FROM users")
        .fetch_all(&pool)
        .await
        .unwrap();

    for row in rows {
        println!("User ID: {}, Name: {}", row.id, row.name);
    }
}
}

Alternative Libraries

Exploration of Other Async Database Libraries Compatible with Tokio
Besides sqlx, there are other asynchronous database libraries like diesel (with async support), tokio-postgres, and mobc. Each offers different features and trade-offs, suitable for various use cases.
Criteria for Selecting an Appropriate Library
When choosing an async database library, consider factors like database compatibility, feature set (e.g., query builders, connection pooling), performance characteristics, community support, and ease of integration with your existing async framework (like Tokio).

Example: Comparison Table or Criteria List
- sqlx: Compile-time query validation, broad database support.
- diesel: Robust query builder, extensive feature set.
- tokio-postgres: Direct, low-level access to PostgreSQL.
- mobc: Generic connection pooling with async support.

In the next sections, we will delve into advanced usage patterns and tips for optimizing asynchronous database interactions using Tokio and these libraries.

5. Advanced Tokio Features

Futures and Streams

In-depth Look at Implementing Futures and Streams in Tokio
Futures and streams are fundamental concepts in asynchronous programming with Tokio. A future represents a single asynchronous computation that will eventually complete with a value. Streams, on the other hand, are similar to futures but can yield multiple values over time.

Implementing Custom Futures and Streams Implementing custom futures and streams involves defining how they are polled. This typically requires implementing the Future or Stream trait and defining the poll method.

Example: Implementing a Custom Future

#![allow(unused)]
fn main() {
use std::pin::Pin;
use std::task::{Context, Poll};
use std::future::Future;

struct MyFuture;

impl Future for MyFuture {
    type Output = String;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Implementation details...
        Poll::Ready("Completed".to_string())
    }
}
}

Example: Implementing a Custom Stream

#![allow(unused)]
fn main() {
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio_stream::Stream;

struct MyStream;

impl Stream for MyStream {
    type Item = i32;

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        // Implementation details...
        Poll::Ready(Some(42))
    }
}
}

Practical Examples and Use Cases
Futures and streams are extensively used for handling asynchronous I/O operations, timers, and other events that occur over time. Streams are particularly useful in scenarios like processing incoming network data, where the data arrives in chunks over time.

Error Handling in Async Contexts

Strategies for Effective Error Handling in Async Tokio Applications
Error handling in asynchronous applications can be more complex due to the nature of concurrent operations. There is nothing all that special - except that we now have an extra case to consider - should your future return a Result, or should you return a Result with a future in the Ok() variant?

Example: Error Handling with Futures (Same as with sync code)

#[tokio::main]
async fn main() {
    let result = async_operation().await;
    match result {
        Ok(value) => println!("Success: {}", value),
        Err(e) => eprintln!("Error: {}", e),
    }
}

async fn async_operation() -> Result<i32, &'static str> {
    // Some async logic...
    Err("An error occurred")
}

Examples of Common Error Scenarios and Solutions
Dealing with timeouts, connection errors, and data parsing issues are common in async programming. Employing timeouts using tokio::time::timeout, handling connection issues gracefully, and safely parsing incoming data are crucial skills.

Example: Handling Timeouts

use tokio::time::{timeout, Duration};

#[tokio::main]
async fn main() {
    match timeout(Duration::from_secs(5), async_operation()).await {
        Ok(Ok(value)) => println!("Completed: {}", value),
        Ok(Err(e)) => eprintln!("Operation error: {}", e),
        Err(_) => eprintln!("Operation timed out"),
    }
}

async fn async_operation() -> Result<String, &'static str> {
    // Simulate long-running operation
    Err("Failed operation")
}

In the next sections, we will continue exploring advanced topics, including interaction with other async libraries, optimizing Tokio applications for performance, and integrating Tokio with synchronous code.

6. Building Real-World Applications with Tokio

Case Studies

Analysis of Real-World Applications Built with Tokio
Tokio has been the foundation for numerous high-performance applications, ranging from web servers to database clients. Analyzing these applications can provide valuable insights into effective async programming patterns.

Example: Web Server Using Hyper and Tokio Hyper, a fast HTTP implementation, often uses Tokio for its async runtime. Web servers built with Hyper and Tokio benefit from non-blocking I/O and efficient connection handling, ideal for high-load environments.

Example: Real-time Data Processing Application Applications requiring real-time data processing, such as financial tickers or chat servers, leverage Tokio's ability to handle high volumes of concurrent data streams efficiently.
Lessons Learned and Best Practices from Existing Projects
Common lessons include the importance of proper task sizing (neither too big nor too small), the effective use of Tokio's synchronization primitives (like Mutex and channels), and the balance between concurrency and parallelism.

Performance Optimization

Techniques for Optimizing Tokio-based Applications
Efficient async programming in Tokio often involves minimizing task switching and ensuring that I/O operations are truly non-blocking. It's also crucial to correctly configure the Tokio runtime, such as choosing the right executor and tuning thread pool sizes.

Example: Optimizing Task Sizes and Concurrency Ensuring that async tasks are appropriately sized and not overly granular can lead to more efficient execution and less overhead.
Profiling and Benchmarking Tools for Tokio
Tools like perf, flamegraph, and Tokio's own tracing facilities can be used to profile and benchmark Tokio applications. These tools help identify performance bottlenecks, such as excessive polling, and provide insights into the runtime behavior of async tasks.

Example: Using flamegraph to Profile a Tokio Application Generating a flamegraph of a Tokio application can visually represent where the application spends most of its time, helping to pinpoint inefficiencies.

In the final section, we will summarize the key takeaways from this lesson and provide guidance for further learning and exploration in the realm of asynchronous programming with Tokio in Rust.

7. Integrating Tokio with Other Async Frameworks

Interoperability Challenges and Solutions

Understanding and Managing Compatibility Between Tokio and Other Async Runtimes
Integrating Tokio with other async frameworks (like async-std or smol) can present challenges, primarily due to differences in their underlying executors and I/O models. These differences can cause compatibility issues, especially when trying to run tasks or futures that depend on specific runtime characteristics.

To manage these challenges, it's essential to understand the core differences between these runtimes. For instance, Tokio uses a work-stealing scheduler and its own reactor for I/O, which might not be compatible with the executors or I/O mechanisms of other frameworks.

Strategies for Interoperability:
- Runtime Bridging: Using compatibility layers or bridges that allow futures from one runtime to be executed on another. For example, tokio-compat can help run Tokio futures on other executors.
- Selective Task Spawning: Carefully choosing where to spawn tasks based on their runtime dependencies, ensuring that each task runs on an executor that supports its requirements.
- Avoiding Runtime-Specific Features: When designing libraries or components intended for cross-runtime use, avoid using features specific to a single runtime, such as Tokio's I/O or time utilities.

Practical Examples of Cross-Runtime Integrations
Here’s an example of how to use a Tokio-based library in an async-std application, highlighting the use of a compatibility layer.

Example: Using Tokio-based Library in async-std Environment

use async_std::task;
use tokio_compat_02::FutureExt; // Compatibility layer

async fn tokio_based_operation() {
    // Operation that requires Tokio runtime
}

fn main() {
    task::block_on(async {
        tokio_based_operation().compat().await;
    });
}

In this example, tokio_compat_02::FutureExt is used to adapt a Tokio-based operation so that it can run within an async-std task. This demonstrates a practical approach to integrating different async runtimes, ensuring broader compatibility and flexibility in application design.

This lesson on integrating Tokio with other async frameworks concludes our exploration into advanced aspects of asynchronous programming with Tokio in Rust. The skills and knowledge gained here provide a strong foundation for building robust, efficient, and interoperable async applications.

Conclusion

Summarizing the Comprehensive Capabilities of Tokio in Rust's Async Landscape

Tokio has established itself as a cornerstone in Rust's asynchronous programming landscape, offering a broad range of capabilities essential for modern, high-performance applications. Throughout this course, we've explored various facets of Tokio, including:

Core Components: Tokio's architecture with tasks, reactors, and executors provides a robust foundation for building async applications.
IO Library: Asynchronous read/write operations and networking capabilities highlight Tokio's strengths in handling IO-bound tasks efficiently.
select! Macro: This powerful feature enables handling multiple asynchronous events concurrently, enhancing the responsiveness and flexibility of applications.
Async Database Libraries: Integrating Tokio with async database libraries like sqlx showcases its versatility in managing asynchronous database operations.
Advanced Features: We delved into implementing custom futures and streams and addressed error handling in async contexts, underscoring Tokio's depth in facilitating complex async workflows.
Real-World Applications: Case studies and performance optimization techniques provided insights into practical applications and best practices in leveraging Tokio's capabilities.
Interoperability with Other Async Frameworks: We examined the challenges and solutions in integrating Tokio with different async runtimes, emphasizing its adaptability.

Other Libraries in the Tokio Ecosystem

Tokio's ecosystem encompasses a range of libraries that complement and extend its core functionalities:

Hyper: A fast and safe HTTP implementation for Rust, often used with Tokio for building web servers and clients.
Tonic: A gRPC over HTTP/2 implementation designed for use with Tokio, facilitating high-performance remote procedure calls.
Mio: A low-level I/O library that forms the basis of Tokio's reactor, handling non-blocking I/O operations.
Tokio-Compat: Provides compatibility layers for integrating with other async runtimes and for bridging different versions of Tokio.
Tracing: A framework for instrumenting Rust programs to collect structured, event-based diagnostics, particularly useful in asynchronous contexts.

In conclusion, Tokio offers a comprehensive, efficient, and robust framework for asynchronous programming in Rust. Its wide array of features, coupled with an extensive ecosystem, makes it a top choice for developers looking to harness the power of async programming in Rust.

Homework

This assignment takes your client-server chat application to the next level by rewriting it to use the asynchronous paradigm with Tokio. Additionally, you'll start integrating a database to store chat and user data, marking a significant advancement in your application's complexity and functionality.

Description:

Asynchronous Rewriting Using Tokio:
- Refactor both the client and server components of your application to work asynchronously, using Tokio as the foundation.
- Ensure all I/O operations, network communications, and other latency-sensitive tasks are handled using Tokio's asynchronous capabilities.
Database Integration:
- Choose a database framework like sqlx, diesel, or any other of your preference to integrate into the server for data persistence.
- Design the database to store chat messages and user data effectively.
User Identification:
- Implement a mechanism for clients to identify themselves to the server. This can range from a simple identifier to a more secure authentication process, depending on your preference and the complexity you wish to introduce.
- Ensure that the identification process is seamlessly integrated into the asynchronous workflow of the client-server communication.
Security Considerations:
- While focusing on the asynchronous model and database integration, keep in mind basic security practices for user identification and data storage.
- Decide on the level of security you want to implement at this stage and ensure it is appropriately documented.
Refactoring for Asynchronous and Database Functionality:
- Thoroughly test all functionalities to ensure they work as expected in the new asynchronous setup.
- Ensure the server's interactions with the database are efficient and error-handled correctly.
Documentation and Comments:
- Update your README.md to reflect the shift to asynchronous programming and the introduction of database functionality.
- Document how to set up and run the modified application, especially any new requirements for the database setup.

Submission:

After completing the asynchronous rewrite and integrating the database, commit and push your updated application to your GitHub repository.
Make sure your repository's README.md is updated with all the necessary instructions and information, and keep the repository public.
Share the link to your repository on our class submission platform.

Deadline:

The deadline for this assignment is Monday, December 4, 2023.

Transitioning to an asynchronous model and introducing database integration are significant steps in developing scalable and efficient applications. These changes will enhance your application's performance and lay the groundwork for more advanced features and functionalities. As always, if you encounter any difficulties or have questions, please don't hesitate to ask for help.

Braiins University