https://github.com/juliog922/rust_toolbox

The project involves constructing a fully-functional, networked key-value store using best practices in Rust.
https://github.com/juliog922/rust_toolbox

distributed-systems key-value networking rust

Last synced: about 2 months ago
JSON representation

The project involves constructing a fully-functional, networked key-value store using best practices in Rust.

• Host: GitHub
• URL: https://github.com/juliog922/rust_toolbox
• Owner: juliog922
• Created: 2024-09-07T21:07:33.000Z (4 months ago)
• Default Branch: main
• Last Pushed: 2024-09-07T21:19:59.000Z (4 months ago)
• Last Synced: 2024-09-07T22:29:50.524Z (4 months ago)
• Topics: distributed-systems, key-value, networking, rust
• Language: Rust
• Homepage:
• Size: 8.79 KB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Practical Networked Applications in Rust

This project focuses on building a practical networked, multithreaded, and asynchronous Rust application. The end goal is to create a key-value database, offering opportunities to explore:

- The Rust crate ecosystem.

- Concurrent data structures.

- Async programming in Rust.

- Key language features.

- Essential Rust tools.

## Project Overview

The project involves constructing a fully-functional, networked key-value store using best practices in Rust. Along the way, you will work with topics such as:

- **Program structure and maintenance** in Rust.

- Applying **tools like `clippy` and `rustfmt`** to ensure code quality.

- Handling errors effectively following Rust's best practices.

- **Serialization** with `serde` for efficient data storage and transfer.

- Implementing **log-structured storage**, inspired by bitcask.

- **Network programming** using `tokio` and the Rust standard library.

- **Benchmarking** using `criterion` for performance testing.

- Writing foolproof parallel code with the **`crossbeam`** crate.

- Exploring **asynchronous programming** with Rust `futures`.

- Learning how to find the right documentation and crates to solve problems in Rust.

## Key Features

- **Concurrency**: Efficiently handle multiple client requests using multithreading and async Rust.

- **Storage**: Build a simple log-structured storage engine inspired by modern key-value stores.

- **Networking**: Implement robust network communication with async Rust and `tokio`.

- **Error Handling**: Leverage Rust’s rich error-handling ecosystem to write reliable, maintainable code.

## Technologies and Tools

The project will use the following technologies and tools:

- **Rust**: The main language of the project, chosen for its performance and safety guarantees.

- **tokio**: A runtime for writing reliable, fast, and secure network applications.

- **serde**: A framework for serializing and deserializing Rust data structures.

- **clippy**: A Rust linter to ensure code quality.

- **rustfmt**: A code formatting tool for maintaining consistency.

- **criterion**: A benchmarking library to test and optimize the performance of the system.

- **crossbeam**: A crate for parallel programming in Rust.

## Goals

This project aims to:

1. Build a fully-functional **key-value store** that can handle multiple clients concurrently.

2. Explore the **best practices** for writing high-performance, reliable Rust applications.

3. Implement **asynchronous network programming** and **multithreading**.

4. Gain hands-on experience with **serialization**, **error handling**, and **performance benchmarking**.