coding-systems（编码系统）

coding-systems

Purpose

This skill equips the AI to handle systems programming using Rust, Nim, Go, and C, focusing on low-level operations, memory safety, FFI (Foreign Function Interface), and performance-critical code. It combines these languages for tasks like OS development, embedded systems, and high-throughput applications.

When to Use

Use this skill for scenarios requiring direct hardware access, memory management, or inter-language calls, such as writing kernel modules, optimizing network servers, or integrating C libraries into modern languages. Avoid for high-level web apps; prefer when performance bottlenecks demand low-level control.

Key Capabilities

• Rust: Enforces memory safety via ownership and borrowing; supports FFI with C using extern "C" blocks.
• Nim: Offers metaprogramming and FFI via importc pragma; compiles to C for performance.
• Go: Provides concurrency with goroutines and channels; uses cgo for FFI to C libraries.
• C: Enables raw memory manipulation and OS interactions; use for performance-critical kernels.
• Specific features: Rust's unsafe blocks for pointer arithmetic; Go's sync package for thread-safe operations; Nim's templates for code generation; C's mmap for direct memory mapping.

Usage Patterns

To accomplish tasks, structure code with language-specific patterns: Use Rust for safe wrappers around C code; employ Go for scalable concurrent systems; leverage Nim for rapid prototyping of C-like code; fall back to C for hardware-level optimizations. For FFI, always define interfaces first (e.g., in C headers), then bind in target languages. Pattern: Import C headers in Rust via #[link(name = "libc")]; in Go, use // #cgo LDFLAGS: -lmylib for linking.

Common Commands/API

• Rust: Build with cargo build --release for optimized binaries; use std::ffi::c_void for FFI pointers. API example: extern "C" fn add(a: i32, b: i32) -> i32 {a + b}
• Nim: Compile with nim c --cc:gcc -d:release myfile.nim; FFI via proc add(a: cint, b: cint): cint {.importc: "add", header: "myheader.h".}
• Nim code snippet: proc add(a: cint, b: cint): cint {.importc.} echo add(1, 2) # Calls external C function
• Go: Run go build -o myapp with cgo; API: import "C" for FFI. Example: C.add(C.int(1), C.int(2))
• Go code snippet: import "C" func main() {println(int(C.add(1, 2)))}
• C: Compile with gcc -O3 -o myprog myfile.c for optimizations; use #include <sys/mman.h> for OS APIs.
• Config formats: Use Cargo.toml for Rust dependencies (e.g., [dependencies] libc = "0.2"); Go's go.mod for modules; Nim's.nimble for packages.

Integration Notes

Integrate by linking languages via FFI: For Rust-C, set build.rs to generate bindings with bindgen; in Go, use cgo directives like // #include "myheader.h". If API keys are needed (e.g., for external tools), set env vars like $RUST_ANALYZER_API_KEY. For cross-language projects, use CMake for unified builds: Add add_subdirectory(rust_project) in CMakeLists.txt. Always handle ABI compatibility; e.g., ensure C functions use __attribute__((visibility("default"))) for export.

Error Handling

In Rust, use Result<T, E> for fallible operations; check with match or ?. For Nim, use exceptions with try/except; e.g., try: raise newException(ValueError, "Error") except: echo "Handled". Go errors return as second values; check with if err!= nil {return err}. C uses errno; wrap with custom error codes. General pattern: Propagate errors up the call stack and log with details, e.g., in Rust: fn safe_add(a: i32) -> Result<i32, String> {if a < 0 {Err("Negative input".to_string())} else {Ok(a + 1)}}.

Concrete Usage Examples

1. FFI Wrapper for C Library in Rust: To call a C function for memory allocation, first define the interface: Use extern "C" {fn malloc(size: usize) -> *mut u8;}. Then, in code: let ptr = unsafe {malloc(1024)}; if ptr.is_null() {panic!("Allocation failed");}. This pattern ensures safe memory handling in performance-critical apps.
2. Concurrent Performance Task in Go: For a high-throughput server, use goroutines: go func() {for i:= 0; i < 100; i++ {fmt.Println(i)}}(); runtime.Gosched(). Integrate with C via cgo for low-level I/O, e.g., to read from a file descriptor, ensuring non-blocking operations for real-time systems.

Graph Relationships

• Cluster: Related to "coding" cluster for general programming skills.
• Tags: Connected via "systems", "low-level", "performance", "coding" to other skills like "ffi-handling" or "memory-management".
• Embedding: Links to skills with similar vectors, such as "os-programming" based on "systems programming low level memory performance ffi os c rust nim go".