DEV Community: Digkill

My Mac had 14 GB free. Here's what was actually eating 250 GB

Digkill — Mon, 20 Jul 2026 22:42:42 +0000

Last week my MacBook greeted me with the classic: "Your disk is almost full." 460 GB drive, 14 GB free. I hadn't downloaded a single movie. I don't keep my photo library on this machine. So where did almost half a terabyte go?

I decided to actually find out instead of just deleting my Downloads folder and hoping. What I found was equal parts fascinating and embarrassing, and I think every developer's Mac looks roughly the same. Here's the full breakdown — and the commands so you can audit yours.

Step 1: Measure before you delete

The golden rule of disk cleanup: never delete anything you haven't measured first. Start with the top-level damage report:

df -h
du -h -d 1 ~ 2>/dev/null | sort -hr | head -20

On my machine this immediately produced suspects:

257G    /Users/me
 87G    /Users/me/Library
 78G    /Users/me/Projects
 10G    /Users/me/.espressif
8.1G    /Users/me/.gemini
3.4G    /Users/me/go
2.2G    /Users/me/.rustup
2.0G    /Users/me/.gradle
1.9G    /Users/me/.cursor

87 GB in ~/Library. Let's zoom in:

du -h -d 1 ~/Library 2>/dev/null | sort -hr | head -10
du -h -d 1 ~/Library/Caches 2>/dev/null | sort -hr | head -15

 29G    ~/Library/Application Support
 24G    ~/Library/Caches
 14G    ~/Library/Arduino15
 10G    ~/Library/Developer

24 GB of caches. Yarn alone was sitting on 5.1 GB. Google's cache folder had 4.3 GB. A disk imaging tool I used once had kept 4.1 GB of downloaded OS images as a souvenir.

The usual suspects (a checklist)

After going through my whole disk, here's what actually eats space on a developer's Mac, roughly in order of guilt:

1. `~/Library/Caches` — the obvious one

Safe to clear almost entirely. Apps rebuild caches on next launch. The catch: it's not one folder, it's hundreds — one per app, including apps you deleted two years ago.

2. Package manager caches — the silent hoarders

Every ecosystem keeps its own stash, and none of them ever clean up after themselves:

du -sh ~/Library/Caches/Yarn ~/.npm/_cacache ~/Library/Caches/pip \
       ~/Library/Caches/Homebrew ~/.gradle/caches ~/go/pkg/mod \
       ~/Library/Caches/CocoaPods ~/.nuget/packages 2>/dev/null

My Go module cache was 3.2 GB of packages for projects I'd finished months ago. All of this re-downloads on demand — it's pure cache.

Fun gotcha: the Go module cache ships with read-only permissions, so a naive rm -rf fails halfway through. You need chmod -R u+w first. Ask me how I know.

3. Xcode — a category of its own

If you do any iOS/macOS development:

du -h -d 1 ~/Library/Developer 2>/dev/null | sort -hr

DerivedData — build intermediates, safe to nuke, rebuilds on next build
iOS DeviceSupport — debug symbols for every iOS version of every device you've ever plugged in, 2–5 GB each
CoreSimulator — old simulators easily hold 20–40 GB across Xcode versions
Archives — every app you've ever shipped, forever

xcrun simctl delete unavailable alone freed several GB of orphaned simulators for me.

4. Build artifacts scattered across your projects

This was my biggest shock: 45 GB of build folders and 8 GB of node_modules spread across ~/Projects.

Finding them is trickier than it sounds, because the folder names are ambiguous. node_modules and __pycache__ are unmistakable, but build, dist, target, vendor? Those could be anything — you can't just delete every folder named build on your disk.

The trick I landed on: validate by marker files. A folder named target is only a Rust build if Cargo.toml sits next to it. build is only sacrificeable if the parent has build.gradle, CMakeLists.txt, package.json, or pubspec.yaml. vendor counts only next to composer.json or go.mod. bin/obj only next to a *.csproj. Python's venv proves itself by containing pyvenv.cfg.

With that heuristic you can sweep your whole home directory safely:

# unambiguous ones are easy:
find ~ -type d \( -name node_modules -o -name __pycache__ -o -name .venv \) \
  -not -path "$HOME/Library/*" -prune -print 2>/dev/null

Everything restores with npm install / cargo build / pip install when you actually return to that project. Spoiler: you won't return to most of them.

5. The weird ones nobody talks about

iOS device backups: ~/Library/Application Support/MobileSync/Backup — old iPhone backups from that one time you used Finder sync. Often 10–50 GB.
Mail Downloads: ~/Library/Containers/com.apple.mail/Data/Library/Mail Downloads — attachments you viewed once, kept forever.
Electron app junk: every Electron/Chromium app keeps Cache, Code Cache, GPUCache, ShaderCache and logs inside ~/Library/Application Support/<App>/. Individually small, collectively gigabytes — Discord, Slack, Postman, Obsidian, all of them.
Old Downloads: find ~/Downloads -maxdepth 1 -mtime +30 — everything untouched for a month. For me that was 25 items including three copies of the same installer.

Safety rules I follow

Trash, not rm — move things to the Trash first, delete permanently only after a week of nothing breaking.
Never touch: ~/Library/Keychains, Mail, Messages, Mobile Documents (that's iCloud!), and on Apple Silicon leave /System/Library/Caches alone — macOS manages it.
Close the heavy apps first — clearing a cache out from under a running browser or IDE causes weirdness.
Look before you delete. Categories like "old downloads" contain surprises — mine had API keys (AuthKey_*.p8) I definitely still needed.

The confession part

I did this cleanup manually with du, find and rm exactly once. It took an evening, I freed about 60 GB… and three weeks later the disk was filling up again, because caches do what caches do.

So — like every developer with a shell history full of du -h -d 1 — I ended up building a small native macOS app that does this loop for me: scans all the locations above (plus auto-discovers caches of any app it finds), tags everything Safe / Caution / Risky, shows the actual file list behind every category with checkboxes, and defaults to moving things to the Trash. The marker-file validation for build folders came straight out of this experiment.

It's free, no subscriptions, signed and notarized, and I mostly built it for myself — but if your df -h looks like mine did, it might save you an evening: Again Cleaner. If you'd rather do it by hand, every command you need is in this post — that's genuinely how the app works under the hood.

Either way: go run du -h -d 1 ~ | sort -hr | head -20 right now. I'll wait. The number next to ~/Library is going to annoy you.

What's the biggest space hog you've found on your machine? I'm collecting new categories — the weirdest one I've heard so far is 30 GB of Slack video call recordings nobody knew existed.

🛠️ The Rise of the Artisan Coder — a New Breed of Developer

Digkill — Wed, 12 Nov 2025 19:58:07 +0000

💡 Term introduced by CTO Vitaliy Edifanov (MediaRise Studio)

In the modern tech world, a new type of developer is emerging — one that blends the precision of engineering, the creativity of design, and the instinct of entrepreneurship.

Meet the Artisan Coder — a digital craftsman who builds products from scratch, combines human creativity with AI automation, and treats software development as both a profession and an art.

👨‍💻 Who Is an Artisan Coder?

An Artisan Coder is more than a full-stack developer.

They are a creator, engineer, and founder all at once — capable of building and launching complete products independently.

They embrace a mindset where programming, design, automation, and business strategy come together in one person.

An Artisan Coder combines:

Engineering mastery — fluent in modern languages, frameworks, and rapid prototyping.
AI-driven workflow — uses GPTs, Copilot, Code Interpreter, or AutoDev to accelerate creation.
Entrepreneurial thinking — understands unit economics, product-market fit, and customer experience.
Aesthetic mindset — writes clean, expressive, and meaningful code.
Cross-domain literacy — familiar with DevOps, UI/UX, analytics, and marketing.

They are not freelancers or corporate coders — they are independent creators of digital ecosystems, often operating as a one-person studio.

⚙️ The Core Principles of the Artisan Coder

Build fast, but think deep. Speed without clarity is chaos — clarity without speed is stagnation.
Automate the routine. AI is your apprentice, not your rival.
Code with aesthetic discipline. Clean code is a signature of respect for your craft.
Think like a founder. Every project should have a reason to exist beyond code.
Share your knowledge. Real mastery is proven through teaching others.

🚀 Why This Movement Is Inevitable

We’re entering an era where one developer with AI tools can outperform entire teams.

The Artisan Coder doesn’t fear automation — they embrace it.

They use it to extend their reach, not replace their creativity.

Just like master craftsmen of the past shaped materials into form, today’s Artisan Coders shape ideas into software — guided by intuition, experience, and AI-powered precision.

This movement reflects a broader shift in tech:

from mass production to intelligent creation,

from corporate engineering to individual mastery.

✨ The Artisan Philosophy

To be an Artisan Coder means to create with purpose.

To find beauty in logic, clarity in complexity, and independence in creation.

It’s not about chasing trends — it’s about building meaningful things with soul, discipline, and curiosity.

Artisan Coders are shaping a future where technology feels more human, and creativity is amplified by intelligence.

💬 Closing Thought

As CTO Vitaliy Edifanov describes it:

“The Artisan Coder is a modern-day craftsman —

someone who uses AI not to replace creativity,

but to give it new hands.”

Written by Vitaliy Edifanov, CTO & Founder at MediaRise Studio

Follow for more insights on AI, creativity, and the future of development.

Experience developing in Rust

Digkill — Sun, 21 Jul 2024 17:56:30 +0000

I am the CEO of my company MediaRise (the company is just starting to develop), with a technical background. I enjoy writing in different languages, or rather trying to work with them. I have heard about a language called Rust for a long time.

Key Features of Rust

Memory Safety: Rust guarantees memory safety by using a system of ownership with rules that the compiler checks at compile time. This prevents common bugs such as null pointer dereferencing and buffer overflows.

Concurrency: Rust makes it easier to write safe concurrent code. The ownership system ensures that data races are avoided, making concurrent programming safer and more efficient.

Performance: Rust is designed for performance. Its zero-cost abstractions mean that you can write high-level code without compromising on performance. Rust code can be as fast as C or C++.

Safe Systems Programming: Rust allows low-level programming without the fear of undefined behavior. It offers control over hardware and memory resources while maintaining safety guarantees.

Modern Language Features: Rust includes modern language features such as pattern matching, type inference, and a powerful macro system. These features help in writing clean and maintainable code.

Cargo and Crates: Rust's package manager, Cargo, and the crates.io ecosystem make dependency management and building projects straightforward and efficient.

Strong Type System: Rust has a strong and static type system that prevents many programming errors at compile time. It includes advanced features such as generics, trait bounds, and lifetimes.

Community and Documentation: Rust has a vibrant and supportive community, with comprehensive documentation and a wealth of learning resources.

These features make Rust a compelling choice for developers looking to build reliable and efficient software.

I was thinking about what to implement in Rust. I wanted to write a Telegram bot that would translate messages in a group chat bidirectionally.

I understand that there are ready-made solutions, but I wanted to create my own "bicycle" and try out a new language for myself — Rust.

I have the idea, and I have no problems creating a Telegram bot, but I encountered an issue with the service that would translate from one language to another. I chose LibreTranslate. To use it for free, you need to deploy the application on your server. So I did: I installed the dependencies and deployed it in a Docker container. There were no issues, except that the application needs to be run with the flag: ./run.sh --api-keys to obtain an api_key. You can read more about setting up and obtaining the api-key for LibreTranslate on the official website.

After deploying the LibreTranslate server and getting the token for the Telegram bot, the next step was to implement the application. After reviewing the official Rust documentation and some GitHub projects, I started creating. I installed Rust and Cargo (the package registry/manager for Rust). After studying the documentation for the teloxide library for creating Telegram bots in Rust, I wrote a handler for message events in the chat.

#[tokio::main]
async fn main() -> ResponseResult<()> {
    dotenv().ok();
    env_logger::init();
    let token_bot = env::var("TELEGRAM_BOT_KEY").expect("TELEGRAM_BOT_KEY not found");

    let bot = teloxide::Bot::new(&token_bot).parse_mode(ParseMode::Html);

    // Create a handler for our bot, that will process updates from Telegram
    let handler = dptree::entry()
        .inspect(|u: Update| {
                    eprintln!("{u:#?}"); // Print the update to the console with inspect
        })

   ...

        .branch(
            Update::filter_message()
                .branch(
                    dptree::endpoint(translate_message),
                )
        );

    // Create a dispatcher for our bot
    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;

    Ok(())
}

async fn translate_message(bot: Bot, msg: Message) -> ResponseResult<()> {
    if let Some(text) = msg.text() {

        match translate(text).await {
            Ok(translated_word) => {
                bot.send_message(msg.chat.id, translated_word).await?;
            }
            Err(e) => {
                bot.send_message(msg.chat.id, format!("Translation error: {}", e)).await?;
            }
        }
    } else {
        bot.send_message(msg.chat.id, "Send me plain text.").await?;
    }

    Ok(())
}

Next is the function itself for requesting a translation from the LiberTranslate API. The translation application determines what language the message is in and translates it into the required one

async fn translate(text: &str) -> ResponseResult<String> {
    let client = reqwest::Client::new();

    let api_translate_url = env::var("API_TRANSLATE_URL").expect("API_TRANSLATE_URL not found");
    let api_translate_key = env::var("API_TRANSLATE_KEY").expect("API_TRANSLATE_KEY not found");
    let api_detect_url = env::var("API_DETECT_URL").expect("API_DETECT_URL not found");
    eprintln!("{text:#?}");

    let detect_request = DetectRequest {
        q: String::from(text),
        api_key: String::from(api_translate_key.clone()),
    };

    let res = client.post(api_detect_url)
        .header("Content-Type", "application/x-www-form-urlencoded")
        .form(&detect_request)
        .send()
        .await?;
    let resp_json = res.json::<Vec<DetectResponse>>().await?;

    let lang = &resp_json[0].language;

    eprintln!("{lang:#?}");
    let target_lang = if lang == "ru" { "th" } else { "ru" };

    let json_object = json!({
                "q": text,
                "source": "auto",
                "target": target_lang,
                "format": "text",
                "alternatives": 3,
                "api_key": api_translate_key
            });

    let json_string = serde_json::to_string(&json_object).unwrap();


    let res = client.post(api_translate_url)
        .body(json_string)
        .header("Content-Type", "application/json")
        .send()
        .await?;

    let resp_json = res.json::<TranslateResult>().await?;
    let translated_word = resp_json.translatedText;
    Ok(translated_word)
}

Result in Telegram chat:
->Hi! How are you?
<-เฮ้! เป็นไงบ้าง?

There were problems with bugs, which were due to the fact that I was using old Rust libraries when I tried to solve the problem using ChatGPT. But the live experience of developers on GitHub helped more, where I watched the implementation of some functionality: API documentation of the bot, working with env (environment files), examples of working with json, sending rest requests, and also the work of the language design.

I'm very excited about the working application because I haven't written in Rust before and it inspired me to study it further. Experienced developers will probably tell you how to optimize the code, which I will be very happy about.

All that remains is to build the application and run it in daemon mode on the server

Build your application using the command:
cargo build --release
Create a unit file for systemd. For example, let's create a file
/etc/systemd/system/translate_bot.service

[Unit]
Description=Translate Bot
After=network.target

[Service]
ExecStart=/path/to/your/application
Restart=always
User=yourusername
Group=yourgroupname
Environment=/path/to/your/.env
WorkingDirectory=/path/to/your/application/directory

[Install]
WantedBy=multi-user.target

Reload your systemd configuration to let it know about the new service:
sudo systemctl daemon-reload
Start the service:
sudo systemctl start translate_bot
Make sure the service is up and running:
sudo systemctl status translate_bot

7.To have your service automatically start when the system starts, run the command:
sudo systemctl enable rust_service

Your Rust application will run as a system service managed by systemd. You can control it using standard systemd commands such as start, stop, restart, and status.

P.S. I would also like to solve the problem with env files so that they can be accessed in a function from main.

Next in my plans: I would like to implement event processing if a new user appears in the chat (and also showers). The user can choose the language in which he would like to receive translations. The users themselves and their settings will be stored in the PostgreSQL database

Thank you all for your attention! I posted the source code on GitHub.

Source on GitHub