skills.rest
lehuuhau1231
lehuuhau1231COMMUNITY
Explore all skills by this author →
GitHub

rust-pro

Develop Rust systems with async patterns, type safety, and performance optimization.

Updated Aug 5, 2025
Search Tags:#web development#performance optimization#systems programming#Rust#async programming#type system
One-click install
npx skills add https://github.com/lehuuhau1231/TechJobs --skill rust-pro-lehuuhau1231
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: rust-pro
Source: https://github.com/lehuuhau1231/TechJobs/tree/main/tech-job-client/.agent/skills/rust-pro
Command: npx skills add https://github.com/lehuuhau1231/TechJobs --skill rust-pro-lehuuhau1231

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill addresses complex Rust development challenges, including advanced async patterns, a robust type system, and building high-performance, memory-safe systems.

Core Features & Use Cases

  • Advanced Rust Language Features: Utilizes Rust 1.75+ features like const generics, lifetime annotations, and macro system for compile-time computation.
  • Ownership & Memory Management: Mastery over ownership rules, reference counting, smart pointers, and memory layout optimization.
  • Async Programming & Concurrency: Advanced async/await patterns with Tokio, stream processing, and channel patterns.
  • Type System & Traits: Deep knowledge of trait implementations, associated types, higher-kinded types, and custom derive macros.
  • Performance & Systems Programming: Optimizes for performance with SIMD, low-level I/O, lock-free programming, and profiling.
  • Web Development & Services: Expertise in web frameworks, HTTP/2/3 support, WebSocket communication, and database integration.
  • Error Handling & Safety: Comprehensive error handling, panic handling, and testing strategies ensure robustness.
  • Testing & Quality Assurance: Strong focus on unit, property-based, and integration testing, along with benchmarking and coverage analysis.
  • Unsafe Code & FFI: Safe abstractions over unsafe code, FFI with C libraries, and system API interfacing.
  • Modern Tooling & Ecosystem: Proficient use of Cargo, clippy, rustfmt, and IDE integration.
  • Behavioral Traits: Follows Rust idioms, emphasizes memory safety, and optimizes for correctness and performance.
  • Knowledge Base: Deep understanding of Rust language features, async programming, web development, and testing methodologies.
  • Response Approach: Focuses on analyzing requirements, designing type-safe APIs, implementing efficient algorithms, and extensive testing.
  • Example Interactions:
    • Design a high-performance async web service with proper error handling.
    • Implement a lock-free concurrent data structure with atomic operations.
    • Optimize this Rust code for better memory usage and cache locality.
    • Create a safe wrapper around a C library using FFI.
    • Build a streaming data processor with backpressure handling.
    • Design a plugin system with dynamic loading and type safety.
    • Implement a custom allocator for a specific use case.
    • Debug and fix lifetime issues in this complex generic code.

Quick Start

Use the rust-pro skill to implement a high-performance, async web service with proper error handling.

Frequently Asked Questions about rust-pro

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement lock-free concurrent data structures with atomic operations in Rust?▼

Lock-free concurrent data structures in Rust are implemented using atomic operations and advanced memory management techniques. This involves leveraging ownership rules, smart pointers, and memory layout optimization to ensure thread safety without explicit locking mechanisms.

What is the best way to handle backpressure in a Rust async streaming data processor?▼

Backpressure in an async streaming data processor is handled using advanced async/await patterns with Tokio. This approach utilizes stream processing and channel patterns to manage data flow rates between producers and consumers effectively.

How do I create a safe wrapper around a C library using Rust FFI?▼

Creating a safe wrapper around a C library using Rust FFI involves building safe abstractions over unsafe code. This requires interfacing with system APIs, managing memory layout, and enforcing Rust's ownership rules to guarantee memory safety at the boundary.

Does this Rust development approach require knowledge of advanced type system features?▼

Yes, this Rust development approach requires deep knowledge of the type system. You need to understand trait implementations, associated types, higher-kinded types, custom derive macros, and const generics to design type-safe APIs.

How do I optimize Rust code for better memory usage and cache locality?▼

Optimizing Rust code for memory usage and cache locality involves utilizing SIMD, low-level I/O, and lock-free programming. Performance profiling and memory layout optimization are applied to ensure high-performance, memory-safe systems programming.

Why do I get lifetime issues in complex generic Rust code and how can I fix them?▼

Lifetime issues in complex generic Rust code occur when references outlive their underlying data. Fixing them requires analyzing requirements, applying advanced lifetime annotations, and designing type-safe APIs to ensure correct reference counting and ownership.

Related Skills

Explore More Software Engineering Skills→
mtaku3mtaku3
2

Rust Ecosystem

Guide Rust project setup with Cargo workspaces, clippy, rustfmt, and cargo-nextest.

Community
Intermediate
vrcmsvrcms
1

rust-testing

Implement TDD workflows and comprehensive testing patterns for Rust projects.

Community
Advanced
SamuelSahaSamuelSaha

Rust Backend Mastery

Build production-ready Rust backends with Axum, Tokio, Serde, and SQLx.

Community
Advanced
Himanshu040604Himanshu040604

rust-async-patterns

Guide advanced Rust async patterns with Tokio, channels, and error handling.

Community
Advanced