Hasty Briefsbeta

All tags

#rust

595 stories total

Bilingual

Rust Use Within the QEMU Emulator Shaping Up Well
a year ago
- QEMU, a key component in Linux virtualization, is seeing experimental support for Rust.
- Progress includes improved Rust bindings and expanded functionality within QEMU's Rust code.
- Rust in QEMU is now compilable on all supported platforms, passing CI and unit tests.
- Specific device models like pl011 and HPET are implemented in Rust, with pl011 using mostly safe code.
- Challenges identified include issues with early bindings code and the need for better crate organization.
Code Wars: Rust vs. C in the Battle for Billion-Device Safety
a year ago
- Rust's advantages in safety-critical applications include inherent memory safety, strict compile-time checks, and first-class test ergonomics.
- A critical vulnerability in Siemens' Nucleus RTOS affected over 3 billion devices, highlighting the risks of memory-unsafe languages.
- Tweede golf's experiment showed Rust implementations prevented arbitrary code execution vulnerabilities found in C code.
- Rust's design prevents unchecked memory access, lack of bounds checking, and implicit trust of external inputs by default.
- Development time for secure Rust implementations was significantly faster than for C, even with vulnerability foreknowledge.
- Memory-safe languages like Rust reduce security risks, as evidenced by Google, Microsoft, and other tech giants.
- Rust is considered the best tool for system-level networking code today, offering overwhelming benefits over C.
- While Rust excels in system-level problems, other safe languages like Python or Go may be faster to iterate with for higher-level tasks.
Feather: Feather: A web framework that skips Rust's async boilerplate and jus
a year ago
- Feather is a lightweight, DX-first web framework for Rust, inspired by Express.js but designed for Rust’s performance and safety.
- Middleware-First Architecture: Everything is a middleware, including route handlers, auth, and logging, all composable and clean.
- Easy State Management Using Context: Feather's Context API simplifies state management without the need for Extractors/Macros.
- Developer Experience First: Feather’s API is minimal, ergonomic, and readable.
- Modular and Extensible: Feather is designed to be modular, allowing users to select only the features they need.
- Great Tooling Out Of The Box: Feather-CLI makes creating APIs and web servers easy.
- Example Usage: Simple code snippets demonstrate how to set up a basic server, use middleware, and manage state with the Context API.
- JWT Support: Feather includes a native JWT module, activated via a cargo feature.
- Community and Contribution: PRs are welcome, and users are encouraged to star the project on GitHub, share it, and build with it.
- Getting Started: Clone the repository, run the example app, and start developing with Feather.
An Interactive Debugger for Rust Trait Errors
a year ago
- Type systems help catch simple mistakes but struggle with complex errors.
- Complex type mechanisms in languages like Rust can lead to lengthy and confusing error messages.
- Diesel, a Rust ORM, uses traits for SQL query validation, which can complicate error diagnostics.
- Argus is an interactive trait debugger for Rust that helps developers understand complex type errors.
- Argus provides GUI-based exploration of the trait inference tree, improving error localization.
- A user study showed developers using Argus localized trait errors 3.3x faster.
- Argus is available as a VSCode extension and its source code is on GitHub.
Memory-safe sudo to become the default in Ubuntu
a year ago
- Ubuntu 25.10 will adopt sudo-rs, a memory-safe reimplementation of sudo written in Rust.
- This change is part of Canonical's effort to improve system resilience by using memory-safe languages like Rust.
- Sudo-rs is developed by the Trifecta Tech Foundation (TTF) as part of their Privilege Boundary initiative.
- Canonical is sponsoring the completion of Milestone 5 for sudo-rs, including features like shell escape prevention and support for older Linux kernels.
- The transition aims to maintain compatibility with existing workflows while omitting niche features from the original sudo.
- Sudo-rs will be default in Ubuntu 25.10, with plans for inclusion in Ubuntu 26.04 LTS after community testing.
- The Trifecta Tech Foundation focuses on open-source infrastructure projects impacting digital security.
- Canonical provides open-source software and services across various systems and industries.
Matt Godbolt sold me on Rust (by showing me C++)
a year ago
- Matt Godbolt's talk on Correct by Construction APIs highlights the challenges in C++ with type safety and how Rust addresses these issues more effectively.
- In C++, even with type aliasing and explicit constructors, it's still possible to misuse types like Quantity and Price without compiler warnings.
- Rust's type system and compiler checks prevent common mistakes, such as swapping argument types or using negative values for unsigned integers, at compile time.
- Rust's handling of runtime input errors, like parsing strings to numbers, forces developers to handle potential errors explicitly, improving code safety.
- The article emphasizes that Rust's design benefits go beyond memory safety, helping developers avoid simple mistakes and write more reliable code.
Brush (Bo(u)rn(e) RUsty SHell) a POSIX and Bash-Compatible Shell in Rust
a year ago
- brush is a POSIX- and bash-compatible shell implemented in Rust.
- It works on Linux, macOS, and experimentally on Windows (via WSL).
- Functional for interactive use but not recommended for production yet.
- Supports most sh and bash scripts, with known limitations tracked in issues.
- Contributions and feedback are welcome; MIT licensed.
- Install via `cargo install --locked brush-shell` or clone the repo.
- Nix and Arch Linux users have specific installation methods.
- Customizable via `~/.brushrc`; processes `.bashrc` by default.
- Known gaps include some `set`/`shopt` options and unimplemented features.
- Tested with 550+ cases comparing output and exit codes with other shells.
- Relies on crates like `reedline`, `clap`, `fancy-regex`, `tokio`, and `nix`.
- Uses `pprof-rs`, `criterion.rs`, and `bash-completion` for testing and support.
- Inspirational shells include `nushell`, `rusty_bash`, and `mvdan/sh`.
Matt Godbolt sold me on Rust (by showing me C++)
a year ago
- Matt Godbolt's talk highlights the challenges in C++ API design and how Rust addresses them more effectively.
- C++ struggles with type safety, allowing silent conversions and misuse of types without warnings.
- Rust provides compile-time checks to prevent type misuse and enforces handling of potential errors.
- The article contrasts C++'s verbose solutions for type safety with Rust's built-in protections.
- Rust's design saves developers from common mistakes, extending beyond memory safety.
- Future articles will cover more topics from Matt Godbolt's talk, including concurrency safety and RAII.
Zed: The Fastest AI Code Editor
a year ago
- Zed is introduced as the world’s fastest AI code editor, built in Rust and open-source under GPL version 3.
- The Agent Panel in Zed allows users to interact with AI agents to perform tasks like code changes, queries, and more without prior setup.
- Zed ensures privacy and security by default, not harvesting user data and requiring confirmation for irreversible actions.
- Users can choose from various language models for the agent, including custom models via Ollama, and customize tool access.
- Zed offers free usage without AI features, with optional paid plans for AI usage (50 prompts/month free, 500 prompts/month for $20).
- The editor supports macOS and Linux currently, with a Windows stable release planned for 2025.
- Future updates include a debugger release, improved AI collaboration, and Windows support.
Ty: A fast Python type checker and language server, written in Rust
a year ago
- An extremely fast Python type checker and language server written in Rust.
- The project is still in development and not ready for production use.
- Questions or bug reports should be submitted as issues in the repository.
- Development occurs in the Ruff repository; pull requests should be opened there for changes in the ruff submodule.
- The project is licensed under the MIT license.
- Contributions are also licensed under MIT without additional terms.
Rust Dependencies Scare Me
a year ago
- The author expresses concern about Rust's dependency management, particularly the ease of adding crates without considering their necessity or maintenance status.
- A personal experience with the 'dotenv' crate, which was found to be unmaintained, led the author to question the need for certain dependencies and to manually implement required functionality.
- The author highlights the complexity and size of dependencies like Tokio and Axum, which, while powerful and well-maintained, contribute significantly to the project's line count.
- Vendoring dependencies resulted in a project with 3.6 million lines of code, dwarfing the author's own contribution of around 1,000 lines, raising concerns about code auditability.
- The author discusses the trade-offs of adding more to Rust's standard library, noting the language's goals of performance, safety, and modularity, especially for embedded systems.
- Questions are raised about how companies like Cloudflare audit their dependencies and the challenges of managing binary sizes and unnecessary features in crates.
- The author concludes by questioning the current state of Rust's dependency ecosystem and what can be done to improve it, while humorously offering their services for Rust roles.
Show HN: Woxi - A Rust-based interpreter for a subset of the Wolfram Language
a year ago
- A Rust-based interpreter for a subset of the Wolfram Language.
- Focuses on CLI scripting with Wolfram Language subset.
- Includes examples like printing random integers and string joining.
- Woxi runs faster than WolframScript due to no kernel overhead.
- Installation requires Rust's cargo or building from source.
- Supports direct command-line evaluation and script execution.
- Comparison table between Woxi and WolframScript commands.
- Encourages contributions via Pull Requests.
- Includes a test suite and related Wolfram Language projects.
Rust Dependencies Scare Me
a year ago
- The author expresses concern about Rust's dependency management, particularly the reliance on crates.io and the potential risks of unmaintained packages.
- A personal experience with the 'dotenv' crate, which was found to be unmaintained, led to questioning the necessity of certain dependencies.
- The author highlights the complexity and size of dependencies in a project, noting that vendored packages resulted in 3.6 million lines of code compared to 11,136 lines without them.
- Concerns are raised about the feasibility of auditing such a large amount of code, especially when personal contributions are minimal (around 1,000 lines).
- The author discusses the trade-offs of adding more to Rust's standard library, considering Rust's goals of performance, safety, and modularity.
- The difficulty of managing dependencies is underscored by examples from companies like Cloudflare and Clickhouse, which also rely on external crates.
- The author questions how to address these dependency management challenges, suggesting a need for better tools or practices.
Std: Mem Is Interesting
a year ago
- The std::mem module in Rust contains functions that are not commonly used but are powerful.
- drop function is used to manually drop a value before it goes out of scope.
- swap, take, and replace functions help manipulate values without unnecessary copies or moves.
- align_of and align_of_val functions return the ABI-required alignment of a type or value.
- discriminant function provides a unique identifier for enum variants, useful for comparison.
- forget function leaks memory by not dropping a value, useful for transferring resources to C code.
- needs_drop function checks if a type requires dropping, based on whether it implements Drop.
- size_of and size_of_val functions return the byte size of a type or value.
- transmute function reinterprets bits of one type as another, requiring both types to be the same size.
- zeroed and MaybeUninit are used for initializing values, with zeroed setting all bits to zero.
- The std::mem module is niche but contains useful functions for specific scenarios.
ToyDB rewritten: a distributed SQL database in Rust, for education
a year ago
- toyDB is a distributed SQL database written in Rust as an educational project.
- Features include Raft distributed consensus, ACID transactions with MVCC-based snapshot isolation, and pluggable storage engines.
- Includes an iterator-based query engine with heuristic optimization and time-travel support.
- Supports SQL features like joins, aggregates, and transactions.
- Originally created in 2020 to learn about database internals, rewritten based on professional experience.
- Designed for simplicity and correctness, not performance or scalability.
- Includes architecture guide, SQL examples, SQL reference, and research materials.
- Can run a local five-node cluster and includes a command-line client.
- Uses Golden scripts for testing and comes with a workload benchmark tool.
- Debugging support via VSCode and CodeLLDB extension.
A Rust API Inspired by Python, Powered by Serde
a year ago
- The article discusses reimplementing Python's dynamic capabilities (like __getattr__) in Rust, leveraging the serde crate for reflection-like behavior.
- It explores creating a Rust API inspired by Python's WMI package, aiming for a clean and intuitive interface over complex implementations.
- The solution involves using Rust's trait system and Serde's Deserialize trait to dynamically query and construct objects, mimicking Python's flexibility.
- A detailed walkthrough of implementing a custom Deserializer for Rust's strict type system is provided, including handling struct names and field values dynamically.
- The article highlights the zero-overhead abstraction achieved by leveraging Rust's compile-time traits and Serde's derive macros for ergonomic API design.
- Future work and alternatives are discussed, including procedural macros and ORM-oriented crates, with a nod to the stability and features of the serde ecosystem.
Show HN: Helixdb – Open-source vector-graph database for AI applications (Rust)
a year ago
- HelixDB is an open-source, high-performance graph-vector database written in Rust, designed for RAG and AI applications.
- Powered by LMDB via Heed3, it offers reliability and modern features tailored for AI and vector-based applications.
- Performance highlights include being 1000x faster than Neo4j, 100x faster than TigerGraph, and on par with Qdrant for vectors.
- Features native support for graph and vector data types, making it ideal for RAG applications.
- Provides the easiest way to store relationships between nodes, vectors, or both.
- Ensures data integrity with ACID compliance and robust storage via LMDB.
- Includes a CLI tool for installation, setup, query compilation, and deployment.
- Supports TypeScript and Python SDKs for querying the database.
- Current focus areas include expanding vector data type capabilities, enhancing query language robustness, and implementing a test suite.
- Long-term projects include developing an in-house graph-vector storage engine and network protocol libraries.
- Licensed under AGPL, with managed services and enterprise support available for selected users.
Don't Unwrap Options: There Are Better Ways
a year ago
- Handling `None` in `Option` without `unwrap()` is a common issue in Rust.
- The `?` operator doesn't work with `Option` in functions returning `Result`.
- Common workarounds include using `unwrap()`, which can lead to runtime panics.
- Solutions include changing the return type to `Result`, using `ok_or`, `match`, or `let-else`.
- `let-else` (stabilized in Rust 1.65) is recommended for its clarity and robustness.
- `anyhow` crate's `context` method is an alternative for applications, not libraries.
- `let-else` is preferred for its standard library support, readability, and flexibility.
OpenTelemetry Protocol with Apache Arrow
a year ago
- Announcement of Phase 2 for OpenTelemetry Protocol with Apache Arrow (OTel-Arrow).
- Goal: Bridge OpenTelemetry data with Apache Arrow for efficient, zero-copy structured data exchange.
- Focus on Rust-based pipelines to explore performance and integration with OpenTelemetry Collector's Golang ecosystem.
- Investigation into end-to-end zero-copy, column-oriented data handling starting from SDK.
- Interest in integrating Apache DataFusion library with OpenTelemetry pipelines for direct data lake connections.
- Development of an end-to-end OTAP pipeline in Rust, embedding telemetry data into Arrow record batches.
- Continued support for Golang components, ensuring compatibility between Go and Rust pipelines.
- Contributions from Laurent Quérel (F5) and Lei Huang (Greptime) for Rust-based prototypes and metric conversions.
- Formation of the OTel-Arrow SIG with scheduled meetings.
Flattening Rust's Learning Curve
a year ago
- Let your guard down and accept Rust's different mental model, including concepts like lifetimes and ownership.
- Treat the borrow checker as a co-author and learn from compiler errors.
- Rust's verbosity, like type annotations, aids readability and refactoring.
- Use tools like clippy lints from day one to enforce good practices.
- Start with baby steps: use `String`, `clone()`, and `unwrap` generously initially.
- Avoid introducing too many new concepts at once; write small, focused code snippets.
- Be accurate in coding; attention to detail speeds up learning.
- Avoid cheating with auto-completion or LLMs; write code manually to build understanding.
- Build muscle memory by writing code without aids to develop intuition.
- Predict compilation outcomes to strengthen understanding of Rust's rules.
- Solve problems yourself before looking up solutions to deepen learning.
- Break your code intentionally to understand compiler messages better.
- Avoid external crates while learning; write your own small libraries.
- Visualize concepts like lifetimes with sketches to aid understanding.
- Map Rust concepts to languages you know, acknowledging subtle differences.
- Don’t guess; details matter in Rust—read error messages thoroughly.
- Use type-driven development to leverage Rust’s type system for correctness.
- Invest time in finding learning resources that match your style.
- Avoid passive learning like watching videos; prefer books or courses.
- Find a coding buddy for pair programming and code reviews.
- Explain Rust concepts to non-Rust developers to test your understanding.
- Believe in Rust's long-term benefits; it’s a day 2 language with compounding rewards.

first prev3next

About|Login

#rust

Rust Use Within the QEMU Emulator Shaping Up Well

Code Wars: Rust vs. C in the Battle for Billion-Device Safety

Feather: Feather: A web framework that skips Rust's async boilerplate and jus

An Interactive Debugger for Rust Trait Errors

Memory-safe sudo to become the default in Ubuntu

Matt Godbolt sold me on Rust (by showing me C++)

Brush (Bo(u)rn(e) RUsty SHell) a POSIX and Bash-Compatible Shell in Rust

Matt Godbolt sold me on Rust (by showing me C++)

Zed: The Fastest AI Code Editor

Ty: A fast Python type checker and language server, written in Rust

Rust Dependencies Scare Me

Show HN: Woxi - A Rust-based interpreter for a subset of the Wolfram Language

Rust Dependencies Scare Me

Std: Mem Is Interesting

ToyDB rewritten: a distributed SQL database in Rust, for education

A Rust API Inspired by Python, Powered by Serde

Show HN: Helixdb – Open-source vector-graph database for AI applications (Rust)

Don't Unwrap Options: There Are Better Ways

OpenTelemetry Protocol with Apache Arrow

Flattening Rust's Learning Curve