#RustChallenge:

What is the output?

A. It will print kernel

B. It will give a compilation error (explain why)

C. It will give a runtime error (explain why)

#rustlang #rust

git-dive is for better understanding why a change was made. Frequently, we work on code bases we didn't start which have too little documentation. Even worse if the original authors are not around. git-blame is an invaluable tool for this but it requires a lot of ceremony to get the information you need.
https://crates.io/crates/git-dive

Const as an auto trait:

https://without.boats/blog/const-as-an-auto-trait/

#RustChallenge:

🦀 #RustQuiz

What is the result?

A. Prints

Rust is Awsome

B. Compilation error
C. Runtime error

This Week in Rust 651

via This Week in Rust (author: TWiR Contributors)

Web Developer Travis McCracken on Building a Private API with Rust

via DEV Community: rust (author: Travis McCracken Web Developer)

Introducing hatch - a capability-based sandbox for MCP

Github repo

Hatch is a capability-based sandbox for MCP (Model Context Protocol) servers on Linux and macOS. Each server runs under a signed TOML manifest that declares its network destinations, filesystem paths, subprocess permissions, and per-tool argument rules in a CEL subset, enforced by user/mount/pid/net namespaces + cgroups + iptables on Linux and sandbox-exec + PF on macOS, plus an SNI-filtering proxy and DNS allowlist for egress. The threat model is the contract: "what hatch does NOT protect against" sits right next to "what it does."

via DEV Community: rust (author: Irfan)

An Open-Source Gym-Style Backtesting Framework for Algorithmic Trading in Rust

via DEV Community: rust (author: Len)

Deploying a Rust MCP Server to Azure Functions

via DEV Community: rust (author: xbill)

How I turned a Rust book into a multilingual, interactive learning platform

via DEV Community: rust (author: born1987-ir)

Ditch the Clunky GUIs: Meet ComChan, the Blazingly Fast Rust Serial Monitor

via DEV Community: rust (author: Vaishnav-sabari-girish)

A tiny Rust CLI I made while learning the language

I'm still pretty new to Rust, and I find I learn best by building small things. So here's one: isdown — a little CLI that checks if services like GitHub, Slack, AWS, or Cloudflare are having issues.

$ isdown check github slack

GitHub:  Up
Slack:   Degraded
  · Slow API (investigating)

It just queries each service's public status endpoint — no API keys or setup. You can also pass any URL, or add --json for scripting.

cargo install --path .

It's nothing groundbreaking, but it gave me a reason to actually use clap, reqwest, async, and a bit of macro magic for the provider registry. I learned a lot, and I'm sure there's plenty I got wrong.

Repo: https://github.com/dariush624/isdown

If you spot something that could be better, I'd genuinely love the feedback — issues and PRs are very welcome. 🙏

via DEV Community: rust (author: Dariush Moshiri)

Termim Is Becoming More Than Just “Better Terminal History”

A few weeks ago, I introduced Termim as a way to stop shell history from bleeding across projects.

The idea was simple:

You run a Docker command in one repo…

then later press ↑ (arrow-up key) somewhere completely different and get unrelated history back.

That friction always felt unnecessary.

Since then, Termim has evolved quite a bit — both technically and conceptually.

From “Project-Aware” to Directory-Aware

One thing I realized while building this:

“Project-aware” wasn’t precise enough.

A lot of work happens inside projects:

● nested backend folders
● monorepos
● temporary workspaces
● isolated environments

So Termim now scopes history to your actual directory context, not project root.

That means:

● cleaner recall
● less irrelevant history
● less searching through noise
● What Changed Recently
● Binary-First Installers

Here's What Changed Recently

Binary-First Installers

Installers were rewritten for:

● Bash
● Zsh
● Fish
● PowerShell

Instead of forcing local builds, Termim now downloads the correct Rust binary automatically.

Also added:

● SHA256 checksum verification
● idempotent installs
● instant activation on Windows
● In-Memory Secret Redaction

In-Memory Secret Redaction

This became important pretty quickly.

Termim now scrubs sensitive data before history is written:

● API keys
● JWTs
● passwords
● tokens

The filtering happens in-memory, so secrets never touch disk history.

Still Zero-Daemon

One thing I wanted to preserve from day one:

No background services.

Termim stays lightweight:

● no daemon
● low latency
● Rust-native execution
● minimal overhead

The shell should still feel fast.

Cross-Shell Parity

Behavior is now consistent across:

● Bash
● Zsh
● Fish
● PowerShell

The core interaction model is:

↑ → your directory history
↓ → predicted next commands

One Unexpected Thing

The most useful feedback I got wasn’t praise.

It was people saying:

“I still don’t understand what this actually does.”

And honestly, they were right.

That feedback forced me to explain the product more concretely, which ended up improving the direction of the project itself.

The real value of Termim isn’t “AI workflow optimization.”

It’s much simpler:

keeping terminal history relevant to where you actually are.

Architecture & Internals

I also added a detailed ARCHITECTURE.md covering:

● state management
● locking
● prediction flow
● shell integration
● execution model

For anyone interested in the internals.

GitHub: https://github.com/akhtarx/termim

Still early. Still refining.
But the direction feels much clearer now.

via DEV Community: rust (author: Md Mim Akhtar)