DEV Community: Valerie Sims

Mastering Rust: Build a High-Performance CLI Application

Valerie Sims — Tue, 22 Sep 2026 15:17:25 +0000

Introduction

Rust has earned its reputation as one of the most powerful languages for systems-level programming — memory-safe, blazingly fast, and built with concurrency in mind from day one. That combination makes it a natural fit for command-line tools, where you want the control of a low-level language without constantly worrying about segfaults or data races.

In this guide, we'll build a simple but functional CLI application in Rust — one that starts instantly and runs efficiently, the kind of snappy performance that feels almost as satisfying as flipping on a neon sign and watching it light up immediately, no delay, no flicker.

Why Rust for CLI Applications?

A few reasons Rust keeps showing up in the CLI tooling space:

Performance — Rust compiles to native machine code and consistently benchmarks close to C/C++, with none of the runtime overhead you get from interpreted languages.
Memory Safety — The ownership and borrowing system catches memory issues at compile time, so there's no garbage collector pausing your program mid-execution.
Fearless Concurrency — Rust's type system prevents data races at compile time, which makes writing multi-threaded CLI tools far less error-prone than in most languages.
Excellent Tooling — Cargo handles dependency management, building, testing, and publishing in one coherent workflow, which makes the whole development experience feel refreshingly modern.

Getting Started

1. Install Rust

The recommended way to install Rust is through rustup, which also manages toolchain updates:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Confirm it installed correctly:

rustc --version

2. Create a New Project

Cargo scaffolds new projects with sensible defaults:

cargo new my_cli_app
cd my_cli_app

This gives you a ready-to-build project with a Cargo.toml manifest and a src/main.rs entry point.

3. Write a Minimal CLI

Open src/main.rs and start simple:

fn main() {
    println!("Hello, Rust CLI!");
}

Run it with:

cargo run

Nothing fancy yet — but notice how fast that comes back. No interpreter warming up, no import resolution. It just runs.

4. Parsing Command-Line Arguments

Real CLI tools need arguments, flags, and options. Rather than hand-rolling a parser, the community has largely standardized on clap — it's well-maintained, ergonomic, and supports a clean derive-macro syntax.

Add it to Cargo.toml:

[dependencies]
clap = { version = "4.0", features = ["derive"] }

Update main.rs:

use clap::Parser;

#[derive(Parser)]
#[command(name = "my_cli_app", about = "A simple Rust CLI example")]
struct Args {
    /// Name to greet
    #[arg(short, long)]
    name: String,
}

fn main() {
    let args = Args::parse();
    println!("Hello, {}!", args.name);
}

Run it:

cargo run -- --name John

Clap also gives you --help output automatically, generated from your struct definitions — a small thing, but it makes your tool feel finished rather than half-built.

5. Building for Release

Debug builds prioritize compile speed over runtime speed. For actual usage, always build in release mode:

cargo build --release

The optimized binary lands in target/release/. It's worth comparing debug vs. release builds on a larger workload — the difference in execution speed is often dramatic, and the release binary starts up just as instantly as a sign flipping on in a dark room — no lag, no waiting.

Where to Go From Here

This is intentionally a minimal starting point. A few natural next steps if you want to take it further:

Subcommands — clap supports nested subcommands (myapp scan, myapp report, etc.) for tools with multiple modes of operation.
Config files — crates like serde + toml let you load persistent settings instead of requiring every flag on every run.
Concurrency — for I/O-heavy or CPU-bound CLI tools, rayon (data parallelism) or tokio (async I/O) can meaningfully cut execution time.
Better error messages — anyhow or miette turn raw Rust errors into readable, user-friendly output.

Conclusion

You've now got a working CLI application in Rust, backed by clap for argument parsing and Cargo for building a release-optimized binary. It's a small example, but it demonstrates the core loop you'll use in almost every Rust CLI project you build going forward.

What made Rust worth learning for me wasn't just the raw speed — it's that speed paired with safety. You get performance that feels effortless once compiled, the way a well-made neon sign just glows steadily without a second thought — but you get there through a compiler that actually catches your mistakes before your users do.

Happy coding.

Anyone know how to trace a low-opacity or faint watermark using Python?

Valerie Sims — Mon, 13 Jul 2026 18:51:09 +0000

I'm working on an image-processing project and ran into a challenge.

Does anyone have experience detecting or tracing very low-opacity (faint) watermarks using Python? I'm not trying to remove them—just identify or highlight where they exist.

I've been looking into approaches like:

OpenCV (contrast enhancement, edge detection, frequency analysis)
Pillow for basic preprocessing
FFT/DCT-based techniques
Template matching (when a watermark pattern is known)

If you've solved a similar problem or know of a good library, research paper, or technique, I'd really appreciate your suggestions.

What approach worked best for you?

Building a Simple Python Script to Bulk Download Images

Valerie Sims — Mon, 13 Jul 2026 18:27:08 +0000

If you've ever needed to grab a bunch of images from a list of URLs — for a dataset, a backup, a scraping project, or just to save some references — writing your own downloader is one of those small utilities that pays for itself pretty quickly. It's also a nice beginner-friendly project if you're getting comfortable with the requests library and basic file handling in Python.

In this post, I'll walk through a lightweight script I put together that downloads single or multiple images, handles errors gracefully, and organizes everything into a folder automatically.

Why Not Just Right-Click and Save?

For one or two images, sure, manual saving is fine. But once you're dealing with dozens (or hundreds) of URLs, doing it by hand gets tedious fast — and error-prone. A script gives you:

Consistency — every image lands in the same folder with a predictable naming pattern
Resilience — one broken link doesn't stop the whole batch
Repeatability — rerun it anytime with a new list of URLs

The Script

Here's the full implementation:

import os
import requests

def download_image(url, folder="downloaded_images", filename=None):
    """
    Downloads a single image from a given URL and saves it to a folder.
    """
    os.makedirs(folder, exist_ok=True)

    if filename is None:
        filename = url.split("/")[-1].split("?")[0]
        if not filename:
            filename = "image.jpg"

    filepath = os.path.join(folder, filename)

    try:
        response = requests.get(url, stream=True, timeout=10)
        response.raise_for_status()

        with open(filepath, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)

        print(f"✅ Downloaded: {filepath}")
        return filepath

    except requests.exceptions.RequestException as e:
        print(f"❌ Failed to download {url}: {e}")
        return None


def download_multiple_images(url_list, folder="downloaded_images"):
    """
    Downloads multiple images from a list of URLs.
    """
    results = []
    for idx, url in enumerate(url_list, start=1):
        print(f"Downloading image {idx}/{len(url_list)}...")
        result = download_image(url, folder=folder)
        results.append(result)
    return results


if __name__ == "__main__":
    # Replace with your own list of image URLs
    image_urls = [
        "https://example.com/image1.jpg",
        "https://example.com/image2.png",
    ]

    download_multiple_images(image_urls)

Breaking It Down

1. Streaming the download

response = requests.get(url, stream=True, timeout=10)

Setting stream=True means the file is downloaded in chunks instead of loading the entire image into memory at once. This matters more than you'd think once you start dealing with larger files — it keeps memory usage flat regardless of image size.

The timeout=10 is a small but important detail: without it, a single unresponsive server can hang your script indefinitely.

2. Writing in chunks

with open(filepath, "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

Instead of writing the whole response body in one go, the script writes 8KB chunks as they arrive. This is the standard pattern for downloading binary files in requests and works well for anything from tiny thumbnails to multi-megabyte images.

3. Graceful failure

except requests.exceptions.RequestException as e:
    print(f"❌ Failed to download {url}: {e}")
    return None

RequestException is the base class for pretty much everything that can go wrong with a requests call — connection errors, timeouts, bad status codes (via raise_for_status()), and so on. Catching it here means one dead link just gets logged and skipped, rather than crashing the whole batch.

4. Auto-naming files

filename = url.split("/")[-1].split("?")[0]

This grabs the last segment of the URL path and strips off any query string, so a URL like https://example.com/photos/sunset.jpg?size=large becomes sunset.jpg. It's not bulletproof (some URLs won't have a clean filename at the end), but it covers the common case, and you can always pass an explicit filename if you need more control.

Using It

Drop your URLs into a list and run it:

image_urls = [
    "https://example.com/image1.jpg",
    "https://example.com/image2.png",
]

download_multiple_images(image_urls)

Every image gets saved into a downloaded_images/ folder in your working directory, created automatically if it doesn't already exist.

Requirements

Just one dependency:

pip install requests

Where You Could Take This Further

This script covers the basics, but there's room to grow it depending on what you need:

Parallel downloads — using concurrent.futures.ThreadPoolExecutor or asyncio + aiohttp to download many images at once instead of sequentially
Content-type validation — checking the response's Content-Type header to confirm you actually got an image before saving it
Retry logic — wrapping the request in a retry decorator for flaky connections
Progress bars — plugging in tqdm for a nicer CLI experience on large batches
Deduplication — hashing file contents to skip images you've already downloaded

Wrapping Up

It's a small script, but it's a good example of how a few well-placed lines — streaming, chunked writes, and proper exception handling — turn a "works on my machine for one file" snippet into something you can actually trust to run unattended on a list of hundreds of URLs.

If you end up extending it (especially the async version), I'd love to hear about it in the comments!

Decking Out My Coding Cave for the Holidays 💻

Valerie Sims — Mon, 13 Jul 2026 18:11:10 +0000

Okay, I'll admit it — the holidays are still weeks away and I'm already deep into decoration mode. As developers, we spend way too many hours in our home office setups, so why not make that space actually feel joyful during the holiday season instead of just... functional?

This year I'm doing something a little different. Instead of going full traditional red-and-green, I'm leaning into a modern, tech-inspired holiday aesthetic — think warm string lights, circuit-board coasters, a few 3D-printed ornaments, and the centerpiece of it all: a custom neon sign.

I recently checked out Beer Neon Sign and honestly got a little too excited scrolling through the options. Something like "Code & Cheer" or "Merry & Bright" glowing softly above my monitor sounds like exactly the vibe I want. I'm also seriously tempted by a beer neon sign for the little relaxation corner next to my desk — perfect for when I close the laptop after a long debugging session and just want to unwind with a drink and some chill lighting.

Since I'm a dev, of course I couldn't resist automating the whole thing. I've got the neon sign and string lights on a smart plug, controlled through a tiny script that syncs with my work calendar:

import schedule
import time
from smart_lights import LightController

lights = LightController(device="office-neon")

def focus_mode():
    lights.dim(20)  # subtle glow, no distractions during deep work

def holiday_mode():
    lights.set_color("warm-white")
    lights.brightness(80)  # full festive glow after hours

schedule.every().day.at("09:00").do(focus_mode)
schedule.every().day.at("18:00").do(holiday_mode)

while True:
    schedule.run_pending()
    time.sleep(60)

Nothing fancy, but it means I get a calm, dim glow while I'm heads-down in a PR review, and the full festive light show kicks in the moment my workday ends. Small thing, but it genuinely makes closing the laptop feel more rewarding.

Here's the balance I'm trying to strike overall: festive, not distracting.

Keep the neon signs on a smart plug/schedule so they dim automatically during focus hours
Pair them with warm-white string lights instead of anything too flashy or color-cycling
Keep the desk itself minimal — decorations around the perimeter, not on my keyboard

Curious how the rest of you approach this:

Anyone else decorating their home office / coding setup for the holidays already?
Traditional decor, or leaning into something more modern/tech-themed like I am?
Are you automating your lights (Home Assistant, smart plugs, custom scripts, etc.)?
Any small dev-themed decor finds worth sharing?

Would love to see everyone's setups — feel free to drop pics, scripts, or ideas below. Happy (early) holiday planning, fellow devs! 🎅