DEV Community: Trish

Recreating strlen and strcmp in Assembly: A Step-by-Step Guide

Trish — Wed, 20 Nov 2024 11:37:58 +0000

Writing low-level functions in assembly might seem daunting, but it’s an excellent way to deepen your understanding of how things work under the hood. In this blog, we’ll recreate two popular C standard library functions, strlen and strcmp, in assembly language and learn how to call them from a C program.

This guide is beginner-friendly, so don’t worry if you’re new to assembly programming. Let’s dive in! 🚀

Introduction to Assembly and C Integration
What Are strlen and strcmp?
Setting Up Your Environment
Writing strlen in Assembly
Writing strcmp in Assembly
Integrating Assembly with C
Compiling and Running the Program
Expected Output
Conclusion
Connect on Twitter

1. Introduction to Assembly and C Integration

Assembly language operates at a very low level, close to machine code. When combined with a high-level language like C, you get the best of both worlds:

High-level readability.
Low-level control and optimization.

In this guide, we’ll write two functions in assembly—my_strlen and my_strcmp—and call them from C to demonstrate this integration.

2. What Are `strlen` and `strcmp`?

strlen: This function calculates the length of a null-terminated string (a string that ends with \0).
strcmp: This function compares two strings character by character. It returns:
- 0 if the strings are identical.
- A negative value if the first string is smaller.
- A positive value if the first string is greater.

We’ll replicate their behavior in assembly.

3. Setting Up Your Environment

Tools Required:

NASM (Netwide Assembler): To assemble the assembly code.
GCC (GNU Compiler Collection): To compile and link the C and assembly code.

Installing the Tools (Linux):

Run the following commands:

sudo apt update
sudo apt install nasm gcc

4. Writing `strlen` in Assembly

Logic of `strlen`:

Start with a counter initialized to 0.
Read each character of the string until the null terminator (\0) is found.
Return the counter as the length.

Assembly Code for `my_strlen`:

section .text
global my_strlen

my_strlen:
    xor rax, rax           ; Set RAX (length) to 0
.next_char:
    cmp byte [rdi + rax], 0 ; Compare current byte with 0
    je .done               ; If 0, jump to done
    inc rax                ; Increment RAX
    jmp .next_char         ; Repeat
.done:
    ret                    ; Return length in RAX

Registers Used:
- RDI: Points to the input string.
- RAX: Stores the string length (output).

5. Writing `strcmp` in Assembly

Logic of `strcmp`:

Compare the characters of two strings.
Stop when the characters differ or the null terminator (\0) is reached.
Return:
- 0 if strings are equal.
- Difference of ASCII values if they differ.

Assembly Code for `my_strcmp`:

section .text
global my_strcmp

my_strcmp:
    xor rax, rax           ; Set RAX (result) to 0
.next_char:
    mov al, [rdi]          ; Load byte from first string
    cmp al, [rsi]          ; Compare with second string
    jne .diff              ; If not equal, jump to diff
    test al, al            ; Check if we’ve hit \0
    je .done               ; If \0, strings are equal
    inc rdi                ; Advance pointers
    inc rsi
    jmp .next_char         ; Repeat
.diff:
    sub rax, [rsi]         ; Return difference
.done:
    ret

Registers Used:
- RDI and RSI: Pointers to the input strings.
- RAX: Stores the result (output).

6. Integrating Assembly with C

Let’s write a C program that calls these assembly functions.

C Code:

#include <stdio.h>
#include <stddef.h>

// Declare the assembly functions
extern size_t my_strlen(const char *str);
extern int my_strcmp(const char *s1, const char *s2);

int main() {
    // Test my_strlen
    const char *msg = "Hello, Assembly!";
    size_t len = my_strlen(msg);
    printf("Length of '%s': %zu\n", msg, len);

    // Test my_strcmp
    const char *str1 = "Hello";
    const char *str2 = "Hello";
    const char *str3 = "World";

    int result1 = my_strcmp(str1, str2);
    int result2 = my_strcmp(str1, str3);

    printf("Comparing '%s' and '%s': %d\n", str1, str2, result1);
    printf("Comparing '%s' and '%s': %d\n", str1, str3, result2);

    return 0;
}

7. Compiling and Running the Program

Save the assembly code to functions.asm.
Save the C code to main.c.
Compile and link them:

   nasm -f elf64 functions.asm -o functions.o
   gcc main.c functions.o -o main
   ./main

8. Expected Output

Length of 'Hello, Assembly!': 17
Comparing 'Hello' and 'Hello': 0
Comparing 'Hello' and 'World': -15

9. Conclusion

By writing strlen and strcmp in assembly, you gain a better understanding of:

Low-level memory operations.
How strings are processed at the machine level.
Integrating assembly with C to leverage the strengths of both languages.

What other C standard library functions would you like to see recreated in assembly? Let me know in the comments below!

10. Connect on Twitter

Enjoyed this guide? Share your thoughts or ask questions on Twitter! Let’s connect and explore more low-level programming together. 🚀

Create a 2D Pong Game with Rust and Bevy: A Step-by-Step Guide

Trish — Sun, 17 Nov 2024 16:04:16 +0000

In this blog, we will create a 2D Pong game using Rust and the Bevy engine. Pong is a classic arcade game and a great starting project for learning game development. The Bevy game engine provides a modern ECS-based architecture that's fun to work with.

By the end of this guide, you'll have your own Pong game, and you can find the complete source code here. Connect with me on Twitter for questions or discussions!

Prerequisites

Rust Installed: If you don’t have Rust installed, get it here.
Basic Rust Knowledge: Familiarity with Rust basics is helpful.
Cargo: The Rust package manager, included with Rust.

Step 1: Set Up a New Bevy Project

Start by creating a new Rust project:

cargo new pong-rs --bin  
cd pong-rs

Add Bevy and Bevy Rapier to your Cargo.toml:

[dependencies]  
bevy = "0.11"  
bevy_rapier2d = "0.23"  
rand = "0.8"

Then, run:

cargo build

Step 2: Initialize the Bevy App

In your main.rs, set up the Bevy application. We’ll configure the window and add core plugins:

use bevy::prelude::*;  
use bevy_rapier2d::prelude::*;  

fn main() {  
    App::new()  
        .add_plugins(DefaultPlugins)  
        .add_plugins(RapierPhysicsPlugin::<NoUserData>::default())  
        .run();  
}

Step 3: Configure the Game Window

Add a window configuration so our game has a fixed size and resolution. Replace the add_plugins(DefaultPlugins) line with:

.add_plugins(DefaultPlugins.set(WindowPlugin {  
    primary_window: Some(Window {  
        resolution: WindowResolution::new(1280., 720.),  
        resizable: false,  
        ..Default::default()  
    }),  
    ..Default::default()  
}))

Now, when you run the game, a window with the specified size will open!

Step 4: Add the Game Components

Define the components for paddles, players, and the ball. Components are essential for the ECS (Entity Component System) architecture in Bevy.

Paddle Component:

#[derive(Component)]  
struct Paddle {  
    move_up: KeyCode,  
    move_down: KeyCode,  
}

Player Enum:

#[derive(Component, Clone, Copy, PartialEq, Eq, Hash)]  
enum Player {  
    Player1,  
    Player2,  
}

Ball Component:

#[derive(Component)]  
struct Ball;

Step 5: Spawn Entities

Create the paddles, ball, and camera.

Add the Camera:

fn spawn_camera(mut commands: Commands) {  
    commands.spawn(Camera2dBundle::default());  
}

Add the Paddles:

fn spawn_players(mut commands: Commands) {  
    commands.spawn((  
        SpriteBundle {  
            transform: Transform::from_translation(Vec3::new(-620., 0., 0.)),  
            sprite: Sprite {  
                color: Color::RED,  
                custom_size: Some(Vec2::new(10., 150.)),  
                ..Default::default()  
            },  
            ..Default::default()  
        },  
        Paddle {  
            move_up: KeyCode::KeyW,  
            move_down: KeyCode::KeyS,  
        },  
        Player::Player1,  
    ));  

    commands.spawn((  
        SpriteBundle {  
            transform: Transform::from_translation(Vec3::new(620., 0., 0.)),  
            sprite: Sprite {  
                color: Color::GREEN,  
                custom_size: Some(Vec2::new(10., 150.)),  
                ..Default::default()  
            },  
            ..Default::default()  
        },  
        Paddle {  
            move_up: KeyCode::ArrowUp,  
            move_down: KeyCode::ArrowDown,  
        },  
        Player::Player2,  
    ));  
}

Step 6: Implement Paddle Movement

Create a system to move paddles based on keyboard input:

fn move_paddle(  
    mut paddles: Query<(&mut Transform, &Paddle)>,  
    input: Res<Input<KeyCode>>,  
    time: Res<Time>,  
) {  
    for (mut transform, paddle) in paddles.iter_mut() {  
        if input.pressed(paddle.move_up) {  
            transform.translation.y += 300. * time.delta_seconds();  
        }  
        if input.pressed(paddle.move_down) {  
            transform.translation.y -= 300. * time.delta_seconds();  
        }  
    }  
}

Step 7: Add Physics with Bevy Rapier

Use Bevy Rapier to add physics to the ball and paddles.

Ball Initialization:

fn spawn_ball(mut commands: Commands) {  
    commands.spawn((  
        SpriteBundle {  
            transform: Transform::from_translation(Vec3::new(0., 0., 1.)),  
            sprite: Sprite {  
                color: Color::WHITE,  
                custom_size: Some(Vec2::new(50., 50.)),  
                ..Default::default()  
            },  
            ..Default::default()  
        },  
        Ball,  
        RigidBody::Dynamic,  
        Collider::ball(25.),  
        Velocity::linear(Vec2::new(300., 300.)),  
    ));  
}

Step 8: Detect Ball Collisions

Use sensors and events to detect when the ball collides with paddles or goals. This system adds interactivity.

Ball Collision System:

fn ball_collision(  
    mut balls: Query<(&mut Velocity, &CollidingEntities)>,  
) {  
    for (mut velocity, collisions) in balls.iter_mut() {  
        for _ in collisions.iter() {  
            velocity.linvel.x *= -1.;  
        }  
    }  
}

Step 9: Add Scoring

Track the score of each player and display it using a UI:

fn spawn_score(mut commands: Commands) {  
    commands.spawn(TextBundle {  
        text: Text::from_section(  
            "0 - 0",  
            TextStyle {  
                font_size: 50.0,  
                color: Color::WHITE,  
                ..Default::default()  
            },  
        ),  
        ..Default::default()  
    });  
}

Step 10: Polish and Play

Tie it all together by adding systems to manage ball resets, scoring, and paddle movement. Finally, run the game:

cargo run

Conclusion

You've successfully built a 2D Pong game using Rust and Bevy! Explore further by adding sound effects, enhancing graphics, or implementing AI opponents.

Check out the complete source code on GitHub. Don’t forget to connect with me on Twitter for more Rust and game development discussions!

Happy coding! 🎮

Writing Your Own Memory Pool Allocator in C

Trish — Sat, 16 Nov 2024 18:23:55 +0000

Writing Your Own Memory Pool Allocator in C: A Step-by-Step Guide

In C, dynamic memory management is a crucial aspect of developing efficient software, particularly in performance-critical applications. While functions like malloc() and free() in the standard library are commonly used, they come with overhead and limitations, such as fragmentation and slower allocation times when called frequently. One solution to these issues is creating a memory pool allocator.

In this blog, we will walk through how to write a simple memory pool allocator from scratch in C. By using a memory pool, we can pre-allocate a large block of memory and manage it manually, reducing fragmentation and improving memory allocation performance.

🔗 Keep the conversation going on Twitter(X): @trish_07

What is a Memory Pool Allocator?

A memory pool allocator is a custom memory management strategy where a large block of memory is pre-allocated, and smaller chunks of it are handed out to the program as needed. When memory is no longer needed, it is returned to the pool for reuse. This approach allows for faster allocation and deallocation than using malloc() and free() directly, as well as better memory utilization.

Here’s how a basic memory pool works:

Pre-allocate a large block of memory.
Divide this block into smaller chunks (blocks).
Keep track of the unused blocks in a free list.
When a block is requested, allocate it from the pool and return it to the caller.
When a block is freed, return it to the pool.

Step 1: Define the Memory Pool Structure

We will begin by defining a simple structure for the memory pool and the blocks within it. Each block will have a pointer to the next block in the free list, which allows us to quickly allocate and free memory.

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>

#define POOL_SIZE 1024  // Total memory pool size

// Define a block structure with a pointer to the next free block
typedef struct Block {
    struct Block *next;
} Block;

// Define the MemoryPool structure
typedef struct {
    Block *freeList;
    unsigned char pool[POOL_SIZE]; // Pre-allocated pool
} MemoryPool;

In this code:

POOL_SIZE is the total size of the memory pool. We will allocate a static array to simulate the pool.
The Block structure represents a single chunk of memory, and it includes a pointer (next) that links it to the next block in the free list.
The MemoryPool structure contains the freeList pointer (which tracks free blocks) and a pool array that holds the actual pre-allocated memory.

Step 2: Initialize the Memory Pool

To initialize the memory pool, we need to divide the pool into blocks and set up the free list. Each block should point to the next free block.

void initMemoryPool(MemoryPool *pool) {
    pool->freeList = (Block *)pool->pool;
    Block *current = pool->freeList;

    // Create a free list of blocks
    for (int i = 0; i < (POOL_SIZE / sizeof(Block)) - 1; i++) {
        current->next = (Block *)((unsigned char *)current + sizeof(Block));
        current = current->next;
    }

    current->next = NULL; // Last block points to NULL
}

In this function:

We initialize the freeList to point to the beginning of the pool.
We then loop through the pool, setting the next pointer of each block to the next one in memory.
Finally, the last block points to NULL to indicate the end of the free list.

Step 3: Allocating Memory from the Pool

To allocate memory, we need to get the first available block from the free list. Once we allocate a block, we remove it from the free list.

void *allocateMemory(MemoryPool *pool) {
    if (pool->freeList == NULL) {
        printf("Memory pool exhausted!\n");
        return NULL;
    }

    // Get the first free block
    Block *block = pool->freeList;
    pool->freeList = block->next; // Move the free list pointer

    return (void *)block;
}

This function checks if the free list is empty. If not, it takes the first free block, removes it from the free list, and returns it to the caller.

Step 4: Freeing Memory and Adding it Back to the Pool

When memory is freed, we return the block to the free list. This allows it to be reused for future allocations.

void freeMemory(MemoryPool *pool, void *ptr) {
    Block *block = (Block *)ptr;
    block->next = pool->freeList; // Add the block to the free list
    pool->freeList = block;
}

Here, we add the freed block to the front of the free list by setting its next pointer to the current first block in the free list. This allows the block to be reused in the future.

Step 5: Example Usage

Now that we have all the necessary functions, let’s put everything together and test our memory pool allocator.

int main() {
    MemoryPool pool;
    initMemoryPool(&pool); // Initialize the pool

    // Allocate a few blocks
    void *block1 = allocateMemory(&pool);
    void *block2 = allocateMemory(&pool);
    printf("Allocated block1: %p\n", block1);
    printf("Allocated block2: %p\n", block2);

    // Free the blocks
    freeMemory(&pool, block1);
    freeMemory(&pool, block2);
    printf("Freed block1 and block2\n");

    return 0;
}

In this example:

We initialize the memory pool using initMemoryPool().
We then allocate two blocks using allocateMemory().
Finally, we free the blocks using freeMemory().

When you run this program, you should see output similar to this:

Allocated block1: 0x55f7f6f34a80
Allocated block2: 0x55f7f6f34a88
Freed block1 and block2

Why Use a Memory Pool?

Performance: Memory pools are typically faster than repeatedly calling malloc() and free() because the overhead of system-level memory management is minimized.
Avoid Fragmentation: Memory pools help avoid fragmentation by allocating fixed-size blocks of memory.
Predictability: Memory allocation becomes predictable since the program controls the allocation and deallocation.

Memory pools are especially useful in real-time systems, embedded systems, and games, where low-latency and memory efficiency are critical.

Conclusion

Writing your own memory pool allocator can significantly optimize memory management for performance-critical applications. By managing memory directly, you can improve allocation speed, reduce fragmentation, and gain more control over how memory is used in your program. While this example is basic, you can extend it with additional features such as different block sizes or thread-safe memory allocation.

If you’re working on a project that requires efficient memory management, consider implementing your own memory pool. It’s a great way to dive deeper into memory management and improve the performance of your application.

Feel free to reach out if you have any questions or need further clarification. Happy coding! 🚀

📦 Comparing Rust’s Smart Pointers: Box, Rc, and Arc

Trish — Tue, 12 Nov 2024 16:33:26 +0000

Rust provides multiple smart pointers to help manage memory safely and efficiently. Each has a unique purpose, so knowing when to use Box, Rc, or Arc can make a big difference in building performant and safe applications. Let’s dive into each one with detailed examples! #RustLang #MemoryManagement #SmartPointers

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

🔹 1. `Box<T>` - Single Ownership and Heap Allocation

Box is Rust’s simplest smart pointer, used to allocate memory on the heap. Box enforces exclusive ownership of its data, which means only one Box instance can own and mutate a given value. It’s ideal for:

Recursive data types (like linked lists or trees) that need heap allocation.
Large data that would otherwise take up too much space on the stack.

Here’s an example of Box with a recursive data structure:

struct Node {
    value: i32,
    next: Option<Box<Node>>, // Recursive data type requires Box to allocate on heap
}

fn main() {
    let node1 = Box::new(Node { value: 10, next: None });
    let node2 = Box::new(Node { value: 20, next: Some(node1) }); // Owned by node2

    println!("Node value: {}", node2.value);
}

🔍 Explanation:

Box<Node> is used here to allocate each Node on the heap.
node2 owns node1 through the next field, creating a basic linked structure.
We can only access data through the owner node2, maintaining Rust’s strict ownership rules.

🟢 Use Box when:

You need single ownership of data.
You have recursive data structures.
You want to store large data on the heap rather than the stack.

🔹 2. `Rc<T>` - Multiple Ownership in Single-Threaded Contexts

Rc (Reference Counted) allows multiple owners of the same data in single-threaded contexts. Rc keeps track of how many references exist, enabling multiple parts of your program to share data without duplicating it. However, Rc is not thread-safe, so it can only be used within a single thread.

Here’s an example of Rc in action:

use std::rc::Rc;

fn main() {
    let shared_data = Rc::new(String::from("Hello, Rc!")); // Create an Rc with initial count of 1

    // Cloning increases reference count but does not copy data
    let owner1 = Rc::clone(&shared_data);
    let owner2 = Rc::clone(&shared_data);

    println!("Owner1: {}, Owner2: {}", owner1, owner2);
    println!("Reference Count: {}", Rc::strong_count(&shared_data)); // Shows 3
}

🔍 Explanation:

Rc::clone creates new references to the same data instead of duplicating it, making Rc efficient for sharing.
Rc::strong_count shows the number of active references, which here is 3.
If shared_data drops, the data will only be deallocated once all references are out of scope, preventing invalid memory access.

🟢 Use Rc when:

You need shared ownership across different parts of your program.
Your application is single-threaded.
You want efficient, reference-counted pointers.

⚠️ Note: Since Rc isn’t thread-safe, using it in multi-threaded contexts will cause compilation errors.

🔹 3. `Arc<T>` - Multiple Ownership Across Threads (Thread-Safe)

Arc (Atomic Reference Counted) is similar to Rc but thread-safe, making it suitable for multi-threaded applications. Arc uses atomic operations to track references, which comes with a small performance cost but ensures safe data sharing across threads.

Let’s look at an example with Arc and threads:

use std::sync::Arc;
use std::thread;

fn main() {
    let shared_data = Arc::new(String::from("Hello, Arc!")); // Arc with initial count of 1

    // Create multiple threads, each with a reference to shared_data
    let handles: Vec<_> = (0..3)
        .map(|_| {
            let data = Arc::clone(&shared_data); // Clone reference safely across threads
            thread::spawn(move || {
                println!("Thread: {}", data);
            })
        })
        .collect();

    for handle in handles {
        handle.join().unwrap();
    }
}

🔍 Explanation:

Arc::clone lets multiple threads access the same data safely.
Each Arc instance in a new thread increases the reference count, ensuring shared_data stays valid as long as it’s in use.
Atomic operations on Arc ensure that no data race conditions occur when sharing across threads.

🟢 Use Arc when:

You need shared ownership across multiple threads.
You want a thread-safe, reference-counted pointer.
You're working with multi-threaded applications.

🚀 Key Differences and When to Use Each

Smart Pointer	Ownership	Thread-Safe	Ideal Use Case
`Box<T>`	Single	No	Recursive structures, heap allocation, large data
`Rc<T>`	Shared (Single)	No	Single-threaded shared ownership
`Arc<T>`	Shared (Multiple)	Yes	Multi-threaded shared ownership

🔹 Quick Reference

Box<T>: For single ownership and heap storage. Perfect for recursive structures and stack memory savings.
Rc<T>: For shared ownership in single-threaded contexts. Useful for data sharing without duplication in single-threaded applications.
Arc<T>: For thread-safe shared ownership. Use this when you need data accessible from multiple threads.

Rust’s ownership model is unique, but understanding these smart pointers makes it easier to leverage memory safety and concurrency. Each of these pointers is tailored for specific needs, so choose wisely based on your application’s requirements. 😊

Happy coding! 🦀 #RustLang

5 Tips for Writing Clean, Idiomatic Rust Code 🦀✨

Trish — Sun, 10 Nov 2024 16:16:32 +0000

Rust is known for its memory safety, performance, and expressive syntax. But writing idiomatic Rust code that’s easy to read and maintain requires practice. Here are five essential tips to help you write clean, idiomatic Rust, with examples to illustrate each one.

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

1. Use `?` for Error Handling Instead of `match`

Error handling is a common task, and the ? operator simplifies this by propagating errors without verbose match statements. It’s especially useful when working with functions that return a Result type, as it allows errors to be passed up the call stack without manual handling in each function.

Example

Consider a function that reads a username from a file. Without the ? operator, we’d handle errors like this:

use std::fs::File;
use std::io::{self, Read};

fn read_username() -> Result<String, io::Error> {
    let mut file = match File::open("username.txt") {
        Ok(file) => file,
        Err(e) => return Err(e),
    };
    let mut username = String::new();
    match file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}

With the ? operator, we can reduce this to a much cleaner version:

use std::fs::File;
use std::io::{self, Read};

fn read_username() -> Result<String, io::Error> {
    let mut username = String::new();
    File::open("username.txt")?.read_to_string(&mut username)?;
    Ok(username)
}

This concise approach maintains readability while reducing boilerplate code.

2. Leverage `if let` for Simple Pattern Matching

The if let construct simplifies pattern matching when only one specific variant matters. It’s ideal for cases where you want to handle Option or Result values without the need for exhaustive matching.

Example

Suppose we want to check if a configuration file path is set and print it only if it exists:

let config = Some("config.toml");

if let Some(file) = config {
    println!("Using config file: {}", file);
}

Instead of a full match statement, if let allows us to handle just the Some case concisely, improving readability.

3. Prefer Iterator Methods Over Loops

Rust’s iterator methods like map, filter, and collect allow for more expressive and functional-style code. Using iterators can make your code more concise, while clearly conveying intent.

Example

Here’s a simple example of doubling each element in a vector using map:

let numbers = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
println!("Doubled: {:?}", doubled);

Instead of a for loop with a mutable vector, map makes it clear that each item in numbers is being doubled and stored in a new vector.

Loop Alternative

To see the difference, here’s how you’d do the same with a for loop:

let numbers = vec![1, 2, 3, 4, 5];
let mut doubled = Vec::new();
for num in &numbers {
    doubled.push(num * 2);
}
println!("Doubled: {:?}", doubled);

Using iterators is cleaner and often preferred in Rust.

4. Use `const` and `static` for Global Values

To avoid “magic numbers” and make your code more configurable, define constants at the global scope. const values are immutable and can be used anywhere, while static allows global mutable data (with some restrictions).

Example

Here’s how to set a constant value for MAX_CONNECTIONS:

const MAX_CONNECTIONS: u32 = 100;

fn main() {
    println!("Max connections allowed: {}", MAX_CONNECTIONS);
}

In this example, MAX_CONNECTIONS can be used throughout your code. It makes the code more understandable by eliminating the need for hardcoded values.

Using `static` with Global Mutable Data

If you need a mutable global variable, use static with lazy_static or once_cell crates to safely initialize and access it.

5. Embrace Enums and Pattern Matching for Complex Data

Enums and pattern matching allow you to handle different types or states of data in a structured way. By matching on enums, you can make your code more readable and expressive.

Example

Suppose we’re writing a function that prints a user’s online status. We could define an enum to represent each possible status:

enum Status {
    Online,
    Offline,
    Busy,
}

fn print_status(status: Status) {
    match status {
        Status::Online => println!("User is online"),
        Status::Offline => println!("User is offline"),
        Status::Busy => println!("User is busy"),
    }
}

Using enums with match statements provides clear handling of each case and allows for future extensibility if new statuses are added.

Advanced Use: Enum with Data

Enums can also hold data, which allows you to handle complex scenarios. For example:

enum Message {
    Text(String),
    Image { url: String, dimensions: (u32, u32) },
}

fn print_message(msg: Message) {
    match msg {
        Message::Text(text) => println!("Text: {}", text),
        Message::Image { url, dimensions } => println!("Image: {} with dimensions {:?}", url, dimensions),
    }
}

Enums make it easy to manage data of different types within a single type, increasing flexibility.

Conclusion

Writing clean, idiomatic Rust code doesn’t just improve readability—it also makes it easier to maintain and understand, especially for larger projects. By following these five tips—using ? for error handling, leveraging if let for pattern matching, preferring iterator methods, defining constants, and embracing enums—you can elevate the quality of your Rust code.

Whether you’re new to Rust or looking to refine your style, adopting these techniques will help you write more elegant, expressive, and idiomatic Rust. Happy coding! 🦀

Top 5 Rust Crates to Make Development Easier 🚀

Trish — Sat, 09 Nov 2024 18:45:58 +0000

Rust is renowned for its safety and performance, but it also has a vibrant ecosystem of crates (libraries) that make development faster and more efficient. In this blog post, we’ll explore five essential Rust crates that simplify common tasks like data serialization, HTTP requests, logging, error handling, and asynchronous programming. Each crate includes an example to help you get started.

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

1. `serde` - Data Serialization and Deserialization Made Simple

serde is a powerful framework for serializing and deserializing Rust data structures into formats like JSON, YAML, and XML. This crate makes it straightforward to handle structured data, which is especially useful for API development, configuration management, and file I/O.

Installing `serde`

Add these lines to your Cargo.toml to include serde and serde_json (for JSON handling):

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Example: Serializing and Deserializing JSON

In this example, we define a simple User struct, serialize it to JSON, and then deserialize it back into a Rust struct.

use serde::{Serialize, Deserialize};
use serde_json;

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    age: u8,
}

fn main() {
    let user = User {
        name: "Alice".to_string(),
        age: 30,
    };

    // Serialize the struct to JSON
    let json = serde_json::to_string(&user).unwrap();
    println!("Serialized JSON: {}", json);

    // Deserialize the JSON back into a Rust struct
    let deserialized_user: User = serde_json::from_str(&json).unwrap();
    println!("Deserialized: {:?}", deserialized_user);
}

2. `reqwest` - HTTP Client for Rust

reqwest is a flexible, easy-to-use HTTP client. It’s perfect for making API requests, fetching data from external sources, and handling complex HTTP interactions.

Installing `reqwest`

Add reqwest to your Cargo.toml file:

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }  # Needed for async runtime

Example: Sending a GET Request

In this example, we use reqwest to send a GET request to a public API and parse the response JSON.

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    // Send a GET request to a sample JSON API
    let response = reqwest::get("https://jsonplaceholder.typicode.com/todos/1").await?;

    // Parse the JSON response
    let json: Value = response.json().await?;
    println!("Response JSON: {:?}", json);

    Ok(())
}

3. `log` and `env_logger` - Simple Logging for Rust Applications

Logging is essential for debugging and monitoring application behavior. The log crate provides a logging interface, while env_logger allows you to configure log levels through environment variables.

Installing `log` and `env_logger`

Add log and env_logger to your Cargo.toml:

[dependencies]
log = "0.4"
env_logger = "0.10"

Example: Basic Logging Setup

In this example, we use info!, warn!, and error! macros to log messages of varying severity levels. env_logger is initialized to control the output of log messages based on environment settings.

use log::{info, warn, error};
use env_logger;

fn main() {
    // Initialize env_logger to configure log level based on environment variables
    env_logger::init();

    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
}

Usage: To see specific levels of log output, run the program with RUST_LOG=info cargo run. This configuration controls which messages are displayed.

4. `anyhow` - Simplified Error Handling

Rust’s type system makes error handling very explicit, which can sometimes be verbose. anyhow simplifies error handling by providing a convenient Result type that can capture complex errors and includes useful context for debugging.

Installing `anyhow`

Add anyhow to your Cargo.toml:

[dependencies]
anyhow = "1.0"

Example: Simplified Error Handling with `anyhow`

In this example, we use anyhow::Result to handle errors in a function that reads a file. anyhow allows us to add context to errors, making it easy to understand where an error originated.

use anyhow::{Result, Context};

fn get_config() -> Result<String> {
    let config = std::fs::read_to_string("config.toml")
        .with_context(|| "Failed to read config file")?;
    Ok(config)
}

fn main() -> Result<()> {
    let config = get_config()?;
    println!("Config contents: {}", config);
    Ok(())
}

If the file is missing or unreadable, the context message "Failed to read config file" will be included in the error message, making debugging easier.

5. `tokio` - Asynchronous Runtime for Rust

tokio is an asynchronous runtime that enables you to write concurrent programs in Rust. It’s widely used for network programming, including building web servers and handling asynchronous I/O operations.

Installing `tokio`

Add tokio to your Cargo.toml:

[dependencies]
tokio = { version = "1", features = ["full"] }

Example: Asynchronous Task with `tokio::sleep`

In this example, we use tokio::sleep to simulate an asynchronous delay between tasks. This example demonstrates how to use async functions and execute them concurrently.

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

#[tokio::main]
async fn main() {
    println!("Task 1 starting...");
    sleep(Duration::from_secs(2)).await;
    println!("Task 1 done!");

    println!("Task 2 starting...");
    sleep(Duration::from_secs(1)).await;
    println!("Task 2 done!");
}

tokio::main enables the async runtime, allowing us to run asynchronous code. Here, sleep pauses each task independently, demonstrating the non-blocking nature of async programming.

Wrapping Up

These five crates—serde, reqwest, log/env_logger, anyhow, and tokio—provide powerful, easy-to-use tools to streamline common tasks in Rust development. From data serialization and HTTP requests to error handling and async programming, they’re essential for writing clean, efficient, and maintainable Rust code.

Each crate has its own strengths, and together, they cover a wide range of development needs. Whether you’re building web applications, CLI tools, or low-level systems, give these crates a try to take your Rust projects to the next level. Happy coding! 🦀

Building a Simple TCP Server in C

Trish — Fri, 01 Nov 2024 19:04:40 +0000

In this blog post, we’ll explore how to create a simple TCP server in C that can serve HTML files. We will break down the code, explain how it works, and discuss future plans for enhancing this project. This is an excellent example of how you can "just do things" in C without overcomplicating the process!

Project Overview

The goal of this project is to implement a basic TCP server that listens for client connections and serves HTML files upon request. The server will handle client requests, read the specified HTML file, and send the contents back to the client as an HTTP response.

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 GitHub Repository: Explore the TCP Server Project Repository

Project Structure

To organize our code, we’ll structure the project as follows:

tcp_server_c/
├── CMakeLists.txt             # Build configuration
├── include/
│   ├── server.h               # Main server header file
│   ├── html_serve.h           # Header for serve_html function
│   ├── request_handler.h      # Header for handle_client function
│   └── socket_utils.h         # Header for socket utility functions
├── src/
│   ├── server.c               # Main server program
│   ├── html_serve.c           # serve_html function
│   ├── request_handler.c      # handle_client function
│   └── socket_utils.c         # Utility functions for socket operations
└── README.md                  # Project documentation

Code Breakdown

1. Socket Utilities

First, let's create a utility file to handle socket initialization. This will ensure that our main server code remains clean and focused.

include/socket_utils.h

#ifndef SOCKET_UTILS_H
#define SOCKET_UTILS_H

#include <arpa/inet.h>

int initialize_server(struct sockaddr_in* address);

#endif

src/socket_utils.c

#include "socket_utils.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define PORT 8080

int initialize_server(struct sockaddr_in* address) {
    int server_fd;
    int opt = 1;

    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("Socket failed!");
        return -1;
    }

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
        perror("setsockopt failed");
        close(server_fd);
        return -1;
    }

    address->sin_family = AF_INET;
    address->sin_addr.s_addr = INADDR_ANY;
    address->sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)address, sizeof(*address)) < 0) {
        perror("Bind failed!");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, 3) < 0) {
        perror("Listen failed!");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

2. HTML Serving Functionality

Next, we will create a function to serve HTML files. This function will read the contents of an HTML file and return them to the caller.

include/html_server.h

#ifndef HTML_SERVER_H
#define HTML_SERVER_H

char* serve_html(const char* filename);

#endif

src/html_server.c

#include "html_server.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* serve_html(const char* filename) {
    FILE* file = fopen(filename, "r");
    if (!file) {
        perror("Error opening file");
        return NULL;
    }

    fseek(file, 0, SEEK_END);
    long length = ftell(file);
    fseek(file, 0, SEEK_SET);

    char* buffer = malloc(length + 1);
    if (!buffer) {
        perror("Error allocating memory");
        fclose(file);
        return NULL;
    }

    fread(buffer, 1, length, file);
    buffer[length] = '\0'; // Null-terminate the buffer

    fclose(file);
    return buffer;
}

3. Handling Client Requests

Now, let’s implement the logic to handle incoming client requests.

include/request_handler.h

#ifndef REQUEST_HANDLER_H
#define REQUEST_HANDLER_H

#include <sys/socket.h>

void handle_client(int new_socket);

#endif

src/request_handler.c

#include "request_handler.h"
#include "html_server.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define BUFFER_SIZE 1024

void handle_client(int new_socket) {
    char buffer[BUFFER_SIZE] = { 0 };
    read(new_socket, buffer, BUFFER_SIZE);

    // Serve the HTML file
    char* html_content = serve_html("../html/index.html");
    if (html_content) {
        write(new_socket, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n", 48);
        write(new_socket, html_content, strlen(html_content));
    } else {
        const char* not_found_response = "HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\n\r\n<h1>404 Not Found</h1>";
        write(new_socket, not_found_response, strlen(not_found_response));
    }

    free(html_content);
    close(new_socket); // Close the connection with the current client
}

4. Main Server Logic

Finally, let’s put everything together in the main file.

src/main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "socket_utils.h"
#include "request_handler.h"

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);

    server_fd = initialize_server(&address);
    if (server_fd == -1) {
        return EXIT_FAILURE;
    }

    printf("Server listening on port: 8080\n");

    while (1) {
        if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
            perror("Connection not accepted!");
            continue;
        }
        handle_client(new_socket); // Handle the client request
    }

    close(server_fd);
    return 0;
}

Future Plans

Moving forward, there are several enhancements and features we plan to implement:

Multi-threading Support: To handle multiple client connections simultaneously, we will introduce threading capabilities to improve the server's efficiency.
Dynamic Content Serving: Implement functionality to serve dynamic content by integrating with a lightweight templating engine.
Logging: Add a logging mechanism to track requests, errors, and server performance.
Security Features: Explore adding HTTPS support and input validation to enhance security.
Improved Error Handling: Implement better error handling for various scenarios, such as file not found, server overload, etc.

Conclusion

This simple TCP server project serves as a foundational example of how to create a web server in C, demonstrating the language's power and simplicity. By building on this foundation, we can develop more sophisticated features and improve performance, making it a robust solution for serving web content.

You can find the complete source code and contribute to the project on GitHub: GitHub Repository Link.

Feel free to provide feedback, ask questions, or contribute your ideas for future enhancements!

Building a CHIP-8 Emulator in Rust - An Advanced Adventure

Trish — Wed, 30 Oct 2024 14:31:09 +0000

Overview

Today's project is a significant step up in complexity as we build a CHIP-8 emulator. CHIP-8 is an interpreted programming language, allowing us to dive into low-level programming concepts, emulation, and understanding of vintage computing architecture.

Difficulty

🏔️ Advanced

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 GitHub Repository: Explore the 7Days7RustProjects Repository

Prerequisites

Solid understanding of Rust
Basic knowledge of computer architecture
Familiarity with emulators or game consoles

Project Structure

First, let's set up our project structure:

mkdir chip8-emulator
cd chip8-emulator
cargo init --bin

Now, let's organize our source code:

chip8-emulator/
│
├── src/
│   ├── audio.rs
│   ├── cpu.rs
│   ├── main.rs
│   ├── util.rs
│   └── window.rs
│
├── Cargo.toml
└── README.md

Step 1: Setting up `Cargo.toml`

[package]
name = "chip8-emulator"
version = "0.1.0"
edition = "2018"

[dependencies]
minifb = "0.19" # For window creation
rodio = "0.14" # For audio

Step 2: `audio.rs` - Handling Beep Sound

use rodio::{
    Sink,
    OutputStream
};

pub struct Audio {
    sink: Sink,
    _stream: OutputStream
}

impl Audio {
    pub fn new() -> Result<Audio, String> {
        let (stream, stream_handle) = match OutputStream::try_default() {
            Ok(v) => v,
            Err(err) => { return Err(err.to_string()); }
        };
        let sink = match Sink::try_new(&stream_handle) {
            Ok(v) => v,
            Err(err) => { return Err(err.to_string()); }
        };
        sink.append(rodio::source::SineWave::new(440.0));
        sink.pause();
        let ret = Audio {sink, _stream: stream};
        Ok(ret)
    }

    pub fn play(&self) {
        self.sink.play();
    }

    pub fn pause(&self) {
        self.sink.pause();
    }
}

Step 3: `cpu.rs` - The Core of the Emulator

use minifb::Key;

use crate::audio::Audio;
use crate::window::Window;
use crate::util::{
    get_bit,
    get_hex_digits
};

const RAM_SIZE: usize = 4096;
const REGISTER_COUNT: usize = 16;
const STACK_SIZE: usize = 16;
const RUNLOOP_TIMER_DEFAULT: usize = 8;
const PROGRAM_START: usize = 0x200;

const RAM_DIGITS: [[u8; 5]; 16] = [
    [0xf0, 0x90, 0x90, 0x90, 0xf0],
    [0x20, 0x60, 0x20, 0x20, 0x70],
    [0xf0, 0x10, 0xf0, 0x80, 0xf0],
    [0xf0, 0x10, 0xf0, 0x10, 0xf0],
    [0x90, 0x90, 0xf0, 0x10, 0x10],
    [0xf0, 0x80, 0xf0, 0x10, 0xf0],
    [0xf0, 0x80, 0xf0, 0x90, 0xf0],
    [0xf0, 0x10, 0x20, 0x40, 0x40],
    [0xf0, 0x90, 0xf0, 0x90, 0xf0],
    [0xf0, 0x90, 0xf0, 0x10, 0xf0],
    [0xf0, 0x90, 0xf0, 0x90, 0x90],
    [0xe0, 0x90, 0xe0, 0x90, 0xe0],
    [0xf0, 0x80, 0x80, 0x80, 0xf0],
    [0xe0, 0x90, 0x90, 0x90, 0xe0],
    [0xf0, 0x80, 0xf0, 0x80, 0xf0],
    [0xf0, 0x80, 0xf0, 0x80, 0x80]
];

pub struct CPU {
    ram: [u8; RAM_SIZE],
    v: [u8; REGISTER_COUNT],
    i: usize,
    dt: u8,
    st: u8,
    stack: [usize; STACK_SIZE],
    sp: usize,
    pc: usize,
    win: Window,
    audio: Audio
}

impl CPU {
    pub fn new(win: Window, audio: Audio) -> CPU {
        let mut ret = CPU {
            ram: [0; RAM_SIZE],
            v: [0; REGISTER_COUNT],
            i: 0,
            dt: 0,
            st: 0,
            stack: [0; STACK_SIZE],
            sp: 0,
            pc: PROGRAM_START,
            win,
            audio
        };
        ret.preload_ram();
        ret
    }

    pub fn load_rom(&mut self, rom: &Vec<u8>) -> Result<(), &str> {
        if PROGRAM_START + rom.len() >= RAM_SIZE {
            return Err("Out of memory: program too large");
        }
        for (j, c) in rom.into_iter().enumerate() {
            self.ram[j + PROGRAM_START] = *c;
        }
        Ok(())
    }

    fn preload_ram(&mut self) {
        for (j, d) in RAM_DIGITS.iter().enumerate() {
            for (k, b) in d.iter().enumerate() {
                self.ram[(0x10 * j) + k] = *b;
            }
        }
    }

    pub fn run_loop(&mut self) -> Result<(), &str> {
        let mut executing = true;
        let mut waiting_for_keypress = false;
        let mut store_keypress_in: usize = 0x0;
        let mut time_to_runloop: usize = RUNLOOP_TIMER_DEFAULT;

        while self.win.is_open() && !self.win.is_key_down(Key::Escape) && self.pc <= RAM_SIZE {
            let keys_pressed = self.win.handle_key_events();

            for (j, k) in keys_pressed.iter().enumerate() {
                if *k {
                    if waiting_for_keypress {
                        executing = true;
                        waiting_for_keypress = false;
                        self.v[store_keypress_in] = j as u8;
                        break;
                    }
                    println!("{:01x} pressed!", j);
                }
            }

            let b1 = self.ram[self.pc] as u16;
            let b2 = self.ram[self.pc + 1] as u16;
            let instruction = (b1 * 256) + b2;
            let mut next_instruction = true;


            if executing {
                println!("{:03x}, {:04x}, {:04x}, {:02x?}", self.pc, instruction, self.i, self.v);
                match instruction {
                    0x00e0 => {
                        self.win.clear_screen();
                    },
                    0x00ee => {
                        if self.sp == 0 {
                            return Err("Stack empty, cannot return from subroutine!");
                        }
                        self.sp -= 1;
                        self.pc = self.stack[self.sp];
                    },
                    0x1000..=0x1fff => {
                        self.pc = get_hex_digits(&instruction, 3, 0);
                        next_instruction = false;
                    },
                    0x2000..=0x2fff => {
                        let loc = get_hex_digits(&instruction, 3, 0);
                        if self.sp == STACK_SIZE {
                            return Err("Stack full, cannot push!");
                        }
                        self.stack[self.sp] = self.pc;
                        self.sp += 1;
                        self.pc = loc;
                        next_instruction = false;
                    },
                    0x3000..=0x3fff => {
                        let val = get_hex_digits(&instruction, 2, 0);
                        let reg = get_hex_digits(&instruction, 1, 2);
                        if self.v[reg] == val as u8 {
                            self.pc += 2;
                        }
                    },
                    0x4000..=0x4fff => {
                        let val = get_hex_digits(&instruction, 2, 0);
                        let reg = get_hex_digits(&instruction, 1, 2);
                        if self.v[reg] != val as u8 {
                            self.pc += 2;
                        }
                    },
                    0x5000..=0x5fff => {
                        let reg1 = get_hex_digits(&instruction, 1, 2);
                        let reg2 = get_hex_digits(&instruction, 1, 1);
                        if self.v[reg1] == self.v[reg2] {
                            self.pc += 2;
                        }
                    },
                    0x6000..=0x6fff => {
                        let val = get_hex_digits(&instruction, 2, 0);
                        let reg = get_hex_digits(&instruction, 1, 2);
                        self.v[reg] = val as u8;
                    },
                    0x7000..=0x7fff => {
                        let val = get_hex_digits(&instruction, 2, 0);
                        let reg = get_hex_digits(&instruction, 1, 2);
                        self.v[reg] = self.v[reg].overflowing_add(val as u8).0;
                    },
                    0x8000..=0x8fff => {
                        let lsb = get_hex_digits(&instruction, 1, 0);
                        let reg1 = get_hex_digits(&instruction, 1, 2);
                        let reg2 = get_hex_digits(&instruction, 1, 1);

                        match lsb {
                            0x0 => {
                                self.v[reg1] = self.v[reg2];
                            },
                            0x1 => {
                                self.v[reg1] |= self.v[reg2];
                            },
                            0x2 => {
                                self.v[reg1] &= self.v[reg2];
                            },
                            0x3 => {y
                                self.v[reg1] ^= self.v[reg2];
                            },
                            0x4 => {
                                let (res, over) = self.v[reg1].overflowing_add(self.v[reg2]);
                                self.v[reg1] = res;
                                self.v[0xf] = if over {1} else {0};
                            },
                            0x5 => {
                                let (res, over) = self.v[reg1].overflowing_sub(self.v[reg2]);
                                self.v[reg1] = res;
                                self.v[0xf] = if over {0} else {1};
                            },
                            0x6 => {
                                let res = self.v[reg1].overflowing_shr(1).0;
                                self.v[0xf] = get_bit(&self.v[reg1], 0);
                                self.v[reg1] = res;
                            },
                            0x7 => {
                                let (res, over) = self.v[reg2].overflowing_sub(self.v[reg1]);
                                self.v[reg1] = res;
                                self.v[0xf] = if over {0} else {1};
                            },
                            0xe => {
                                let res = self.v[reg1].overflowing_shl(1).0;
                                self.v[0xf] = get_bit(&self.v[reg1], 7);
                                self.v[reg1] = res;
                            },
                            _ => {
                                println!("Warning: unrecognized instruction: {:04x}", instruction);
                            }
                        };
                    },
                    0x9000..=0x9fff => {
                        let reg1 = get_hex_digits(&instruction, 1, 2);
                        let reg2 = get_hex_digits(&instruction, 1, 1);
                        if self.v[reg1] != self.v[reg2] {
                            self.pc += 2;
                        }
                    },
                    0xa000..=0xafff => {
                        self.i = get_hex_digits(&instruction, 3, 0);
                    },
                    0xb000..=0xbfff => {
                        self.pc = get_hex_digits(&instruction, 3, 0) + self.v[0] as usize;
                        next_instruction = false;
                    },
                    0xc000..=0xcfff => {
                        let rnd = rand::random::<u8>();
                        let val = get_hex_digits(&instruction, 2, 0);
                        let reg = get_hex_digits(&instruction, 1, 2);
                        self.v[reg] = rnd & val as u8;
                    },
                    0xd000..=0xdfff => {
                        let reg1 = get_hex_digits(&instruction, 1, 2);
                        let reg2 = get_hex_digits(&instruction, 1, 1);
                        let init_x = self.v[reg1];
                        let init_y = self.v[reg2];
                        let mut byte_count = get_hex_digits(&instruction, 1, 0);
                        let mut bytes_to_print: Vec<u8> = Vec::new();
                        let mut j = 0;
                        while byte_count > 0 {
                            bytes_to_print.push(self.ram[self.i + j]);
                            byte_count -= 1;
                            j += 1;
                        }
                        self.v[0xf] = self.win.draw(&bytes_to_print, init_x, init_y);
                    },
                    0xe000..=0xff65 => {
                        let d1 = get_hex_digits(&instruction, 1, 3);
                        let d2 = get_hex_digits(&instruction, 1, 2);
                        let d3 = get_hex_digits(&instruction, 1, 1);
                        let d4 = get_hex_digits(&instruction, 1, 0);

                        if d1 == 0xe && d3 == 0x9 && d4 == 0xe {
                            if keys_pressed[self.v[d2] as usize] {
                                self.pc += 2;
                            }
                        }

                        else if d1 == 0xe && d3 == 0xa && d4 == 0x1 {
                            if !keys_pressed[self.v[d2] as usize] {
                                self.pc += 2;
                            }
                        }

                        else if d1 == 0xf && d3 == 0x0 && d4 == 0x7 {
                            self.v[d2] = self.dt;
                        }

                        else if d1 == 0xf && d3 == 0x0 && d4 == 0xa {
                            executing = false;
                            waiting_for_keypress = true;
                            store_keypress_in = d2;
                        }

                        else if d1 == 0xf && d3 == 0x1 && d4 == 0x5 {
                            self.dt = self.v[d2];
                        }

                        else if d1 == 0xf && d3 == 0x1 && d4 == 0x8 {
                            self.st = self.v[d2];
                        }

                        else if d1 == 0xf && d3 == 0x1 && d4 == 0xe {
                            self.i += self.v[d2] as usize;
                        }

                        else if d1 == 0xf && d3 == 0x2 && d4 == 0x9 {
                            self.i = (0x10 * self.v[d2]) as usize;
                        }

                        else if d1 == 0xf && d3 == 0x3 && d4 == 0x3 {
)
                            self.ram[self.i] = self.v[d2] / 100;
                            self.ram[self.i+1] = (self.v[d2] % 100) / 10;
                            self.ram[self.i+2] = self.v[d2] % 10;
                        }

                        else if d1 == 0xf && d3 == 0x5 && d4 == 0x5 {
                            for j in 0..=d2 {
                                self.ram[self.i+j] = self.v[j];
                            }
                        }

                        else if d1 == 0xf && d3 == 0x6 && d4 == 0x5 {
                            for j in 0..=d2 {
                                self.v[j] = self.ram[self.i+j];
                            }
                        }

                        else {
                            println!("Warning: unrecognized instruction: {:04x}", instruction);
                        }
                    },
                    _ => {
                        println!("Warning: unrecognized instruction: {:04x}", instruction);
                    }
                };

                if next_instruction {
                    self.pc += 2;
                }
            }

            if time_to_runloop == 0 {
                if self.dt > 0 { self.dt -= 1; }

                if self.st > 0 {
                    self.audio.play();
                    self.st -= 1;
                }
                else if self.st == 0 {
                    self.audio.pause();
                }

                self.win.refresh();

                time_to_runloop = RUNLOOP_TIMER_DEFAULT;
            }
            else {
                time_to_runloop -= 1;
            }
        }
        Ok(())
    }
}

Step 4: `window.rs` - Display and Input

use minifb::{
    Key,
    WindowOptions,
    Scale,
    Error
};

use crate::util::is_bit_set;

const WIDTH: usize = 64;
const HEIGHT: usize = 32;
const PX_OFF: u32 = 0x81c784;
const PX_ON: u32 = 0x29302a;

pub struct Window {
    win: minifb::Window,
    framebuffer: [u32; WIDTH * HEIGHT]
}

impl Window {
    pub fn new(title: &str) -> Result<Window, Error> {
        let mut win = match minifb::Window::new(
            title,
            WIDTH,
            HEIGHT,
            WindowOptions {
                scale: Scale::X8,
                ..WindowOptions::default()
            }
        ) {
            Ok(win) => win,
            Err(err) => {
                return Err(err);
            }
        };
        // 480 Hz
        win.limit_update_rate(Some(std::time::Duration::from_micros(2083)));
        Ok(Window { win, framebuffer: [PX_OFF; WIDTH * HEIGHT] })
    }

    pub fn handle_key_events(&self) -> [bool; 16] {
        let mut keys = [false; 16];
        self.win.get_keys().iter().for_each(|k| {
            match k {
                Key::Key1 => keys[0x1] = true,
                Key::Key2 => keys[0x2] = true,
                Key::Key3 => keys[0x3] = true,
                Key::Key4 => keys[0xc] = true,
                Key::Q => keys[0x4] = true,
                Key::W => keys[0x5] = true,
                Key::E => keys[0x6] = true,
                Key::R => keys[0xd] = true,
                Key::A => keys[0x7] = true,
                Key::S => keys[0x8] = true,
                Key::D => keys[0x9] = true,
                Key::F => keys[0xe] = true,
                Key::Z => keys[0xa] = true,
                Key::X => keys[0x0] = true,
                Key::C => keys[0xb] = true,
                Key::V => keys[0xf] = true,
                _ => ()
            };
        });
        keys
    }

    pub fn is_key_down(&self, key: Key) -> bool {
        self.win.is_key_down(key)
    }

    pub fn is_open(&self) -> bool {
        self.win.is_open()
    }

    pub fn clear_screen(&mut self) {
        for j in 0..self.framebuffer.len() {
            self.framebuffer[j] = PX_OFF;
        }
    }

    pub fn draw(&mut self, bytes: &Vec<u8>, init_x: u8, init_y: u8) -> u8 {
        let mut collision: u8 = 0;
        for (k, b) in bytes.iter().enumerate() {
            for j in 0..8 {
                let x = (init_x as usize + j) % WIDTH;
                let y = (init_y as usize + k) % HEIGHT;
                let coord = (y * WIDTH) + x;
                let is_old_set = self.framebuffer[coord] == PX_ON;
                self.framebuffer[coord] = if is_bit_set(b, (8-j-1) as u8) {
                    if is_old_set { collision = 1; PX_OFF }
                    else { PX_ON }
                } else { self.framebuffer[coord] };
            }
        }
        collision
    }

    pub fn refresh(&mut self) {
        self.win.update_with_buffer(&self.framebuffer, WIDTH, HEIGHT).unwrap();
    }
}

Step 5: `util.rs` - Utility Functions

pub fn get_hex_digits(n: &u16, d: u32, o: u32) -> usize {
    let base: u16 = 0x10;
    ((n / base.pow(o)) % base.pow(d)) as usize
}

pub fn is_bit_set(byte: &u8, n: u8) -> bool {
    if byte & (1 << n) == 0 { false } else { true }
}

pub fn get_bit(byte: &u8, n: u8) -> u8 {
    if is_bit_set(byte, n) { 1 } else { 0 }
}

Step 6: `main.rs` - Orchestrating Everything

extern crate minifb;
extern crate rand;
extern crate rodio;

use std::{
    fs,
    env
};

mod cpu;
use cpu::CPU;

mod audio;
use audio::Audio;

mod window;
use window::Window;

mod util;

fn main() {
    println!("chip8-rust: CHIP-8 emulator written in Rust");

    let args: Vec<String> = env::args().collect();

    if args.len() != 2 {
        return eprintln!("Usage: {} <rom-file-name>", args[0]);
    }

    let filename = String::from(&args[1]);

    let rom = match fs::read(&filename) {
        Err(why) => {
            return eprintln!("Could not open file: {}", why.to_string());
        },
        Ok(file) => file
    };

    let audio = match Audio::new() {
        Ok(a) => a,
        Err(err) => {
            return eprintln!("Could not initialize audio device: {}", err);
        }
    };

    let win = match Window::new(&format!("chip8-rust: {}", filename)) {
        Ok(win) => win,
        Err(err) => {
            return eprintln!("Could not initialize window: {}", &err.to_string());
        }
    };

    let mut cpu = CPU::new(win, audio);
    match cpu.load_rom(&rom) {
        Ok(()) => (),
        Err(err) => {
            return eprintln!("Could not initialize CPU: {}", err);
        }
    };

    match cpu.run_loop() {
        Ok(()) => (),
        Err(err) => {
            return eprintln!("CPU crashed: {}", err);
        }
    }
}

Step 7: Running Your Emulator

To run:

sudo apt-get install libsdl2-dev

cargo run romfile.ch8

Explanation

Audio: We use rodio to handle audio, creating a simple beep sound for the CHIP-8's sound timer.
CPU: This is where the magic happens. The CPU fetches, decodes, and executes opcodes. You'd implement specific instructions here.
Window: Using minifb, we create a window to display the CHIP-8 graphics and handle input.
Main: Brings everything together, running the emulation loop.

Conclusion

Building a CHIP-8 emulator is a deep dive into low-level programming, teaching you about memory management, instruction sets, and real-time systems. While this example provides a skeleton, full implementation requires handling all CHIP-8 instructions, managing timers, and ensuring accurate emulation speed. Extend this project by:

Implementing full CHIP-8 opcode support.
Adding proper cycle timing for different CHIP-8 versions.
Improving the audio system for varied tones or volume control.

This project offers a hands-on look at how vintage games were run and opens doors to understanding modern emulation techniques.

Rust TUI Chat Application - Mastering Terminal User Interfaces

Trish — Tue, 29 Oct 2024 13:18:46 +0000

Overview

Today, we're going to build a chat application using Rust's terminal user interface (TUI) libraries. This application will allow two instances to communicate over a network, simulating a simple chat. We'll use tui for the interface and tokio for asynchronous networking.

Difficulty

🌲 Advanced

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 GitHub Repository: Explore the 7Days7RustProjects Repository

Prerequisites

Intermediate Rust knowledge
Familiarity with asynchronous programming
Basic understanding of networking in Rust

Project Structure

First, let's set up our project:

mkdir rust-tui-chat
cd rust-tui-chat
cargo init --bin

Now, let’s define our folder structure:

rust-tui-chat/
│
├── src/
│   ├── main.rs
│   ├── ui.rs
│   ├── network.rs
│   └── message.rs
│
├── Cargo.toml
└── README.md

Step 1: Setting up `Cargo.toml`

[package]
name = "rust_tui_chat"
version = "0.1.0"
edition = "2018"

[dependencies]
crossterm = "0.20"
tokio = { version = "1", features = ["full"] }
tokio-util = { version = "0.6", features = ["codec"] }
tui = { version = "0.16", default-features = false, features = ['crossterm'] }
anyhow = "1.0"

Step 2: `ui.rs` - Terminal User Interface

use tui::{
    backend::CrosstermBackend,
    layout::{Constraint, Direction, Layout},
    widgets::{Block, Borders, Paragraph},
    Terminal,
};
use crossterm::{
    event::{self, DisableMouseCapture, Event, KeyCode},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};

pub struct Ui {
    terminal: Terminal<CrosstermBackend<std::io::Stdout>>,
}

impl Ui {
    pub fn new() -> Result<Self, anyhow::Error> {
        enable_raw_mode()?;
        let mut stdout = std::io::stdout();
        execute!(stdout, EnterAlternateScreen)?;
        let backend = CrosstermBackend::new(stdout);
        let terminal = Terminal::new(backend)?;
        Ok(Self { terminal })
    }

    pub fn draw(&mut self, input: &str, messages: &[String]) -> Result<(), anyhow::Error> {
        self.terminal.draw(|f| {
            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .margin(1)
                .constraints([Constraint::Percentage(80), Constraint::Percentage(20)].as_ref())
                .split(f.size());
            let messages_block = Block::default().title("Chat").borders(Borders::ALL);
            let input_block = Block::default().title("Input").borders(Borders::ALL);
            f.render_widget(messages_block, chunks[0]);
            f.render_widget(Paragraph::new(input), chunks[1]);
        })?;
        Ok(())
    }

    pub fn cleanup(&mut self) -> Result<(), anyhow::Error> {
        disable_raw_mode()?;
        execute!(self.terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture)?;
        self.terminal.show_cursor()?;
        Ok(())
    }
}

Step 3: `network.rs` - Network Communication

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

pub struct Network {
    stream: Option<TcpStream>,
}

impl Network {
    pub async fn new(addr: &str) -> Result<Self, anyhow::Error> {
        let stream = if addr.contains(":") {
            TcpStream::connect(addr).await?
        } else {
            let listener = TcpListener::bind(addr).await?;
            let (stream, _) = listener.accept().await?;
            stream
        };
        Ok(Self { stream: Some(stream) })
    }

    pub async fn send_message(&mut self, msg: &str) -> Result<(), anyhow::Error> {
        if let Some(stream) = self.stream.as_mut() {
            stream.write_all(&[msg.len() as u8]).await?;
            stream.write_all(msg.as_bytes()).await?;
        }
        Ok(())
    }

    pub async fn receive_message(&mut self) -> Result<String, anyhow::Error> {
        if let Some(stream) = self.stream.as_mut() {
            let mut len = [0u8; 1];
            stream.read_exact(&mut len).await?;
            let mut buffer = vec![0; len[0] as usize];
            stream.read_exact(&mut buffer).await?;
            return String::from_utf8(buffer).map_err(|e| e.into());
        }
        Err(anyhow::anyhow!("No stream available"))
    }
}

Step 4: `message.rs` - Message Handling

pub struct Message {
    pub text: String,
}

impl Message {
    pub fn new(text: String) -> Self {
        Message { text }
    }
}

Step 5: `main.rs` - Main Application Logic

mod ui;
mod network;
mod message;

use anyhow::Result;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<()> {
    let mut ui = ui::Ui::new()?;
    let (tx, rx) = mpsc::channel();
    let mut network = network::Network::new("127.0.0.1:8080").await?;

    let handle = thread::spawn(move || {
        let mut input = String::new();
        loop {
            if let Ok(Event::Key(key)) = event::read() {
                match key.code {
                    KeyCode::Char(c) => input.push(c),
                    KeyCode::Enter => {
                        let _ = tx.send(input.clone());
                        input.clear();
                    },
                    KeyCode::Backspace => { input.pop(); },
                    KeyCode::Esc => break,
                    _ => {},
                }
            }
        }
    });

    let mut messages = Vec::new();
    loop {
        match rx.try_recv() {
            Ok(msg) => {
                network.send_message(&msg).await?;
                messages.push(msg);
            },
            Err(_) => {
                if let Ok(msg) = network.receive_message().await {
                    messages.push(msg);
                }
            },
        }
        ui.draw(&input, &messages)?;
        thread::sleep(Duration::from_millis(100));
    }

    ui.cleanup()?;
    handle.join().unwrap();
    Ok(())
}

Step 6: Running Your Chat App

To run the application:

cargo run

Explanation

UI: We've used tui for creating a clean, interactive terminal interface where users can see messages and type their own.
Networking: Async networking with tokio allows for sending and receiving messages over TCP. Here, you can run one instance as the server and another as the client locally or over a network.
Message Handling: Simple struct to manage messages in our application.

Conclusion

This project is an advanced step into Rust programming, combining TUI, networking, and asynchronous programming. It opens the door to further enhancements like:

Adding user authentication.
Implementing chat rooms or private messaging.
Enhancing the UI with more widgets or color.

This chat application serves as a solid foundation for experimenting with terminal applications and network communication in Rust.

2D Game Renderer in Rust - Let's Make a Mini RPG!

Trish — Mon, 28 Oct 2024 14:40:55 +0000

Introduction

Welcome to the world of game development in Rust! Today, we'll build a simple 2D RPG game renderer. We'll use ggez for our graphics needs, focusing on creating a game where players can move a character around a tile-based map, interact with objects, and perhaps even battle some basic enemies.

Difficulty

🌳 Intermediate-Advanced

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 GitHub Repository: Explore the 7Days7RustProjects Repository

Prerequisites

Intermediate Rust knowledge
Basic understanding of 2D graphics
Familiarity with game loop concepts

Project Structure

Let's organize our project:

mkdir rust-2d-rpg
cd rust-2d-rpg
cargo init --bin

Here’s our folder structure:

rust-2d-rpg/
│
├── src/
│   ├── main.rs
│   ├── game.rs
│   ├── map.rs
│   ├── player.rs
│   ├── enemy.rs
│   └── assets/
│       ├── player.png
│       ├── enemy.png
│       └── tile.png
│
├── Cargo.toml
└── README.md

Step 1: Setting Up `Cargo.toml`

Add the following dependencies to your Cargo.toml:

[package]
name = "rust-2d-rpg"
version = "0.1.0"
edition = "2018"

[dependencies]
ggez = "0.6.1"
rand = "0.8.4"

Step 2: `main.rs` - The Entry Point

mod game;
mod map;
mod player;
mod enemy;

use ggez::{Context, ContextBuilder, GameResult};
use ggez::event::{self, EventHandler};

fn main() -> GameResult {
    let cb = ContextBuilder::new("rust_2d_rpg", "YourName")
        .window_setup(ggez::conf::WindowSetup::default().title("2D RPG in Rust"));
    let (mut ctx, event_loop) = cb.build()?;
    let game = game::Game::new(&mut ctx)?;
    event::run(ctx, event_loop, game)
}

Step 3: `game.rs` - Game Logic

use ggez::{Context, GameResult};
use ggez::event::{self, EventHandler};
use ggez::graphics;

pub struct Game {
    player: player::Player,
    map: map::Map,
    enemies: Vec<enemy::Enemy>,
}

impl Game {
    pub fn new(ctx: &mut Context) -> GameResult<Game> {
        let player = player::Player::new(ctx)?;
        let map = map::Map::new();
        let enemies = vec![enemy::Enemy::new(ctx)?];
        Ok(Game { player, map, enemies })
    }
}

impl EventHandler for Game {
    fn update(&mut self, _ctx: &mut Context) -> GameResult {
        // Update logic for player movement, enemy behavior, etc.
        Ok(())
    }

    fn draw(&mut self, ctx: &mut Context) -> GameResult {
        graphics::clear(ctx, [0.1, 0.2, 0.3, 1.0].into());
        self.map.draw(ctx)?;
        self.player.draw(ctx)?;
        for enemy in &self.enemies {
            enemy.draw(ctx)?;
        }
        graphics::present(ctx)?;
        Ok(())
    }
}

Step 4: `player.rs` - Player Management

use ggez::{Context, GameResult};
use ggez::graphics::{self, Rect};
use ggez::nalgebra as na;

pub struct Player {
    position: na::Point2<f32>,
}

impl Player {
    pub fn new(_ctx: &mut Context) -> GameResult<Player> {
        Ok(Player { position: na::Point2::new(100.0, 100.0) })
    }

    pub fn draw(&self, ctx: &mut Context) -> GameResult {
        let rectangle = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            Rect::new(self.position.x, self.position.y, 32.0, 32.0),
            graphics::Color::new(0.0, 1.0, 0.0, 1.0),
        )?;
        graphics::draw(ctx, &rectangle, (na::Point2::new(0.0, 0.0),))
    }

    // Add methods for movement, collision detection, etc.
}

Step 5: `map.rs` - World Generation

use ggez::{Context, GameResult};
use ggez::graphics;

pub struct Map {
    // Simplified map representation
    tiles: Vec<Vec<bool>>,
}

impl Map {
    pub fn new() -> Map {
        let tiles = vec![vec![true; 20]; 15];
        Map { tiles }
    }

    pub fn draw(&self, ctx: &mut Context) -> GameResult {
        let tile_size = 32.0;
        for (y, row) in self.tiles.iter().enumerate() {
            for (x, &tile) in row.iter().enumerate() {
                if tile {
                    let rectangle = graphics::Mesh::new_rectangle(
                        ctx,
                        graphics::DrawMode::fill(),
                        graphics::Rect::new((x as f32) * tile_size, (y as f32) * tile_size, tile_size, tile_size),
                        [0.5, 0.5, 0.5, 1.0].into(),
                    )?;
                    graphics::draw(ctx, &rectangle, (na::Point2::new(0.0, 0.0),))?;
                }
            }
        }
        Ok(())
    }
}

Step 6: `enemy.rs` - Enemies Management

use ggez::{Context, GameResult};
use ggez::graphics;
use ggez::nalgebra as na;

pub struct Enemy {
    position: na::Point2<f32>,
}

impl Enemy {
    pub fn new(ctx: &mut Context) -> GameResult<Enemy> {
        Ok(Enemy { position: na::Point2::new(200.0, 200.0) })
    }

    pub fn draw(&self, ctx: &mut Context) -> GameResult {
        let rectangle = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            graphics::Rect::new(self.position.x, self.position.y, 32.0, 32.0),
            graphics::Color::new(1.0, 0.0, 0.0, 1.0),
        )?;
        graphics::draw(ctx, &rectangle, (na::Point2::new(0.0, 0.0),))
    }

    // Add methods for enemy movement, AI, etc.
}

Step 7: Running the Game

To run the game:

cargo run

Explanation

Main Loop: In main.rs, we set up the ggez context and our game loop.
Game State: game.rs holds the overall game state, including the player, map, and enemies.
Graphics: Each component (Player, Map, Enemy) has its own draw method to handle rendering.
Expansion: This basic setup can be expanded with:
- Player movement using keyboard input.
- Collision detection between the player and map/enemies.
- Basic AI for enemy movement or behavior.
- Inventory system for items.
- Combat mechanics or interaction with the environment.

Conclusion

You've now built a foundational 2D RPG game renderer in Rust! This project introduces you to game development concepts, graphics handling with ggez, and modular code organization.

Feel free to expand upon this base by:

Implementing player input for movement.
Adding different types of tiles or interactive objects.
Creating a combat system or quests.
Enhancing the game with sound or more complex graphics.

This project serves as an excellent platform for learning advanced Rust programming and game development principles. Keep exploring, and have fun creating your own game worlds!

Building Real-Time Communication with Rust

Trish — Tue, 01 Oct 2024 17:13:02 +0000

Introduction:
Real-time communication (RTC) in Rust can be achieved through various protocols and frameworks. This guide focuses on basic TCP networking and introduces concepts like WebSockets for real-time interaction.

Prerequisites:

Basic Rust knowledge.
Familiarity with networking concepts (like TCP/IP).
Rust installed on your system.

Step 1: Setting Up the Project

Initialize Cargo Project:

   cargo new rust_rtc
   cd rust_rtc

Add Dependencies: For this tutorial, we might use tokio for asynchronous operations and tokio-udp for UDP if exploring beyond TCP.

   [dependencies]
   tokio = { version = "1", features = ["full"] }
   tokio-udp = "0.2"

Step 2: Understanding TCP Basics

TCP (Transmission Control Protocol): Ensures reliable, ordered delivery of a stream of bytes between applications running on hosts communicating by an IP network.

Step 3: Writing a Simple TCP Server and Client

Server:

   use tokio::net::TcpListener;
   use tokio::prelude::*;

   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let listener = TcpListener::bind("127.0.0.1:8080").await?;
       println!("Server running on 127.0.0.1:8080");

       loop {
           let (mut socket, _) = listener.accept().await?;
           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(e) => {
                           eprintln!("failed to read from socket; err = {:?}", e);
                           return;
                       }
                   };
                   if let Err(e) = socket.write_all(&buf[0..n]).await {
                       eprintln!("failed to write to socket; err = {:?}", e);
                       return;
                   }
               }
           });
       }
   }

Client:

   use tokio::net::TcpStream;
   use tokio::prelude::*;

   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let addr = "127.0.0.1:8080";
       let mut stream = TcpStream::connect(addr).await?;
       println!("Connected to server");

       let data = b"Hello, server!";
       if let Err(e) = stream.write_all(data).await {
           eprintln!("failed to write data; err = {:?}", e);
       }

       let mut buf = vec![0; 1024];
       match stream.read(&mut buf).await {
           Ok(size) => println!("The server responded with {} bytes", size),
           Err(e) => eprintln!("failed to read data; err = {:?}", e),
       }
       Ok(())
   }

Step 4: Exploring WebSockets for Real-Time

WebSockets: Protocol providing full-duplex communication channels over a single TCP connection.

Using tokio-tungstenite for WebSockets:

Add to Cargo.toml:

   [dependencies]
   tokio = { version = "1", features = ["full"] }
   tungstenite = "0.16"

Server Setup:

   use tokio::net::TcpListener;
   use tungstenite::accept_hdr;
   use tungstenite::protocol::WebSocketConfig;
   use tungstenite::handshake::server::Request;

   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let listener = TcpListener::bind("127.0.0.1:8080").await?;
       println!("WebSocket Server running on 127.0.0.1:8080");

       loop {
           let (tcp_stream, _) = listener.accept().await?;
           tokio::spawn(async move {
               let ws_stream = accept_hdr(tcp_stream, Request::default(), &WebSocketConfig::default()).unwrap();
               handle_connection(ws_stream).await;
           });
       }
   }

   async fn handle_connection(ws_stream: tungstenite::WebSocket<tokio::net::TcpStream>) {
       let (mut socket, _) = ws_stream.split();
       while let Some(Ok(msg)) = socket.next().await {
           println!("Received: {:?}", msg);
           if let Err(e) = socket.send(msg).await {
               eprintln!("Error sending message: {}", e);
               break;
           }
       }
   }

Step 5: Enhancing with Real-Time Features

Chat Server Example: Implement a basic chat system where messages are broadcast to all connected clients.

Read the full blog here.

Conclusion:
This tutorial provided a basic walkthrough of TCP networking and introduced WebSocket communication in Rust. Real-time communication in Rust can be expanded further with libraries like tokio for asynchronous networking or tokio-websockets for more WebSocket functionality. Remember, real-time systems in Rust can leverage its performance benefits while ensuring memory safety, making it ideal for networked applications requiring low latency and high throughput.

Further Reading:

Explore tokio for deeper async networking.
Look into rust-websocket for more WebSocket examples.
Beej's Guide to Network Programming for foundational networking concepts applicable to Rust.

This guide provides a starting point, encouraging developers to explore further into Rust's ecosystem for networking tools and libraries tailored for real-time communication.

C++ in Kernel Development: A Comprehensive Guide

Trish — Sun, 29 Sep 2024 16:14:43 +0000

Introduction

Kernel development is traditionally the realm of C due to its direct hardware access and minimal runtime overhead. However, C++ has found its niche in kernel programming due to its object-oriented features, which can lead to cleaner, more maintainable code. This guide will walk through using C++ for kernel development, focusing on setting up an environment, structuring your project, and writing kernel code with C++ features, all while keeping in mind the unique requirements of kernel programming.
Visit here for more articles.

In a hurry?

If you're just looking for the full article then visit. GenXJourney

Prerequisites

Operating System: Linux for this guide, though concepts are generally applicable.
C++ Compiler with Kernel Support: GCC or Clang with necessary flags for kernel compilation.
Kernel Headers: Matching your kernel version.
Build System: We'll use CMake due to its modern approach, though Makefiles are also common.

Setting Up Your Environment

Install Necessary Tools:
- GCC or Clang
- CMake
- Kernel Headers

   sudo apt-get install build-essential cmake

For kernel headers, if you're using a standard distribution:

   sudo apt-get install linux-headers-$(uname -r)

Create Project Structure:

   kernel-cpp/
   ├── build/
   ├── src/
   │   ├── drivers/
   │   ├── kernel/
   │   ├── utils/
   │   └── main.cpp
   ├── include/
   │   ├── drivers/
   │   └── utils/
   ├── CMakeLists.txt
   └── Kconfig

Writing Kernel Code with C++

Let's start with a simple kernel module as an example:

`src/main.cpp`

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <cstddef>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple C++ kernel module");

static int __init hello_cpp_init(void) {
    printk(KERN_INFO "Hello, C++ Kernel World!\n");
    return 0;
}

static void __exit hello_cpp_exit(void) {
    printk(KERN_INFO "Goodbye, C++ Kernel World!\n");
}

module_init(hello_cpp_init);
module_exit(hello_cpp_exit);

`CMakeLists.txt`

cmake_minimum_required(VERSION 3.10)
project(KernelCppModule VERSION 1.0 LANGUAGES CXX)

# Define kernel version
set(KERNEL_VERSION "5.4.0-26-generic")

# Include directories
include_directories(/usr/src/linux-headers-${KERNEL_VERSION}/include)

# Source files
set(SOURCES
    src/main.cpp
)

# Compile settings
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mno-pie -fno-pie -fno-stack-protector -fno-asynchronous-unwind-tables -fwhole-program")

add_library(${PROJECT_NAME} MODULE ${SOURCES})
set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "")

# Link against kernel modules
target_link_libraries(${PROJECT_NAME}
    PRIVATE
        m
        ${CMAKE_SOURCE_DIR}/usr/src/linux-headers-${KERNEL_VERSION}/arch/x86/kernel/entry.o
)

# Install the module
install(TARGETS ${PROJECT_NAME} DESTINATION /lib/modules/${KERNEL_VERSION}/extra/)

Compiling and Loading

Build the Module:

   mkdir build
   cd build
   cmake ..
   make

Install the Module:

   sudo make install

Load the Module:

   sudo insmod kernel-cpp.ko

View the output with:

   dmesg | tail

Advanced C++ Features in Kernel Code

Exception Safety

In kernel space, exceptions are generally disabled or require special handling due to the lack of a standard library:

// Instead of exceptions, use return codes or error handling objects
int divide(int a, int b, int &result) {
    if (b == 0) {
        printk(KERN_ERR "Division by zero\n");
        return -EINVAL;
    }
    result = a / b;
    return 0;
}

RAII (Resource Acquisition Is Initialization)

RAII principles work well in kernel contexts, helping manage resources like memory or file descriptors:

class FileDescriptor {
    int fd;
public:
    FileDescriptor() : fd(-1) {}
    ~FileDescriptor() { if (fd != -1) close(fd); }
    int open(const char *path, int flags) {
        fd = ::open(path, flags);
        return fd;
    }
};

Templates

Templates can be used judiciously for generic programming, but remember the kernel's execution context:

template<typename T>
T* getMemory(size_t size) {
    void* mem = kmalloc(size * sizeof(T), GFP_KERNEL);
    if (!mem) return nullptr;
    return static_cast<T*>(mem);
}

Conclusion

While C++ isn't traditional for kernel development due to overhead concerns, its features can lead to cleaner, safer code if used with kernel-specific considerations in mind. This guide provided a foundation for starting with C++ in kernel space, covering setup, compilation, and fundamental C++ use cases. Remember, kernel programming requires deep understanding of hardware interaction, low-level memory management, and system architecture beyond standard application development. Always ensure your code adheres to kernel best practices regarding performance, memory usage, and safety.

DEV Community: Trish

Recreating strlen and strcmp in Assembly: A Step-by-Step Guide

Table of Contents

1. Introduction to Assembly and C Integration

2. What Are strlen and strcmp?

3. Setting Up Your Environment

Tools Required:

Installing the Tools (Linux):

4. Writing strlen in Assembly

Logic of strlen:

Assembly Code for my_strlen:

5. Writing strcmp in Assembly

Logic of strcmp:

Assembly Code for my_strcmp:

6. Integrating Assembly with C

C Code:

7. Compiling and Running the Program

8. Expected Output

9. Conclusion

10. Connect on Twitter

Create a 2D Pong Game with Rust and Bevy: A Step-by-Step Guide

Prerequisites

Step 1: Set Up a New Bevy Project

Step 2: Initialize the Bevy App

Step 3: Configure the Game Window

Step 4: Add the Game Components

Paddle Component:

Player Enum:

Ball Component:

Step 5: Spawn Entities

Add the Camera:

Add the Paddles:

Step 6: Implement Paddle Movement

Step 7: Add Physics with Bevy Rapier

Ball Initialization:

Step 8: Detect Ball Collisions

Ball Collision System:

Step 9: Add Scoring

Step 10: Polish and Play

Conclusion

Writing Your Own Memory Pool Allocator in C

Writing Your Own Memory Pool Allocator in C: A Step-by-Step Guide

🔗 Keep the conversation going on Twitter(X): @trish_07

What is a Memory Pool Allocator?

Step 1: Define the Memory Pool Structure

Step 2: Initialize the Memory Pool

Step 3: Allocating Memory from the Pool

Step 4: Freeing Memory and Adding it Back to the Pool

Step 5: Example Usage

Why Use a Memory Pool?

Conclusion

📦 Comparing Rust’s Smart Pointers: Box, Rc, and Arc

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

🔹 1. Box<T> - Single Ownership and Heap Allocation

🔹 2. Rc<T> - Multiple Ownership in Single-Threaded Contexts

🔹 3. Arc<T> - Multiple Ownership Across Threads (Thread-Safe)

🚀 Key Differences and When to Use Each

🔹 Quick Reference

5 Tips for Writing Clean, Idiomatic Rust Code 🦀✨

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

1. Use ? for Error Handling Instead of match

Example

2. Leverage if let for Simple Pattern Matching

Example

3. Prefer Iterator Methods Over Loops

Example

Loop Alternative

4. Use const and static for Global Values

Example

Using static with Global Mutable Data

5. Embrace Enums and Pattern Matching for Complex Data

Example

Advanced Use: Enum with Data

Conclusion

Top 5 Rust Crates to Make Development Easier 🚀

🔗 Keep the conversation going on Twitter(X): @trish_07

🔗 Explore the 7Days7RustProjects Repository

1. serde - Data Serialization and Deserialization Made Simple

2. What Are `strlen` and `strcmp`?

4. Writing `strlen` in Assembly

Logic of `strlen`:

Assembly Code for `my_strlen`:

5. Writing `strcmp` in Assembly

Logic of `strcmp`:

Assembly Code for `my_strcmp`:

🔹 1. `Box<T>` - Single Ownership and Heap Allocation

🔹 2. `Rc<T>` - Multiple Ownership in Single-Threaded Contexts

🔹 3. `Arc<T>` - Multiple Ownership Across Threads (Thread-Safe)

1. Use `?` for Error Handling Instead of `match`

2. Leverage `if let` for Simple Pattern Matching

4. Use `const` and `static` for Global Values

Using `static` with Global Mutable Data

1. `serde` - Data Serialization and Deserialization Made Simple

Installing `serde`

2. `reqwest` - HTTP Client for Rust

Installing `reqwest`

3. `log` and `env_logger` - Simple Logging for Rust Applications

Installing `log` and `env_logger`

4. `anyhow` - Simplified Error Handling

Installing `anyhow`

Example: Simplified Error Handling with `anyhow`

5. `tokio` - Asynchronous Runtime for Rust

Installing `tokio`

Example: Asynchronous Task with `tokio::sleep`

Step 1: Setting up `Cargo.toml`

Step 2: `audio.rs` - Handling Beep Sound

Step 3: `cpu.rs` - The Core of the Emulator

Step 4: `window.rs` - Display and Input

Step 5: `util.rs` - Utility Functions

Step 6: `main.rs` - Orchestrating Everything

Step 1: Setting up `Cargo.toml`

Step 2: `ui.rs` - Terminal User Interface

Step 3: `network.rs` - Network Communication

Step 4: `message.rs` - Message Handling

Step 5: `main.rs` - Main Application Logic

Step 1: Setting Up `Cargo.toml`

Step 2: `main.rs` - The Entry Point

Step 3: `game.rs` - Game Logic

Step 4: `player.rs` - Player Management

Step 5: `map.rs` - World Generation