DEV Community: Mateusz Okulanis

Tired of Manual Setup? Automate Your Ubuntu/Debian Environment with My Dotfiles!

Mateusz Okulanis — Mon, 02 Jun 2025 20:00:45 +0000

Hey everyone! 👋

Have you ever felt that nagging feeling after a fresh OS install? You know, the one where you just dread setting up your entire development environment from scratch? Installing all your favorite tools, configuring git, setting up Docker, getting your bashrc just right... it’s like Groundhog Day, but with more apt install commands!

That was me, repeatedly. 😩

I got so tired of running the same setup scripts over and over on different machines that I decided to do something about it. And that's how setup-dotFiles was born!

What is `setup-dotFiles`?

It's a comprehensive collection of dotfiles and configuration scripts designed to automate the setup of your development environment on Ubuntu (24.04, 22.04, 20.04) and Debian (Bookworm, Bullseye). My goal was simple: make system setup quick, consistent, and headache-free.

Why should YOU care? (Or, "What's in it for you, seriously?")

Imagine this:

Scenario 1: New Laptop Day! 🎉 You just got a shiny new machine. Instead of spending hours installing everything, you clone setup-dotFiles, run one script, grab a coffee, and come back to a fully configured environment. No more forgetting that one crucial git config!
Scenario 2: Setting up a Dev Server! 🖥️ Need to quickly spin up a consistent dev server? This project handles all the core installations (like Docker!) for you, ensuring uniformity across your machines.
Scenario 3: Collaborating on a Project! 🤝 You can fork this repo, customize it for your team's specific needs, and ensure everyone has the exact same baseline environment, reducing "it works on my machine" issues.

This isn't just about my setup; it's designed to be YOUR setup. Fork it, customize it, make it yours!

What can it do for you? (Features at a glance!)

I've packed in a bunch of useful automations:

Essential Packages: Automatically installs git, build-essential, curl, and more.
Git Global Settings: Sets up your global user.name and user.email, and core.fileMode (super handy for cross-OS dev!).
Productivity Power-ups: Installs and configures tmux (for persistent sessions!) and fzf (for fuzzy finding files like a wizard!).
Docker Ready: Full Docker installation and configuration, including adding your user to the docker group. No more sudo docker! (Just remember to log out/in after).
RAM Disk Setup: Creates a ~/RAMDISC for super fast temporary operations.
Custom bashrc: Integrates my customized bashrc for a snappier terminal experience.
VS Code & Tailscale: Options to install popular tools like Visual Studio Code and Tailscale.
SSH Key Generation: Helps you quickly set up new SSH keys for GitHub, GitLab, etc.

Play Safely: Docker Test Environment! 🐳

Worried about running scripts directly on your main system? I totally get it! That's why setup-dotFiles includes a Docker-based test environment.

You can test all the scripts in an isolated Ubuntu 24.04 container without touching your host system.

How to use it:

Clone the repository:

git clone [https://github.com/FPGArtktic/setup-DotFiles.git](https://github.com/FPGArtktic/setup-DotFiles.git)
cd setup-DotFiles # Make sure you're in the right directory

Run the test script:
```
./docker_test.sh
```
This builds an Ubuntu 24.04 image, creates a container, and drops you into an interactive bash session. Inside the container, you can run ./setup-dotFile.sh and see exactly what happens!

Ready to Install on Your System?

If you're feeling brave and want to deploy it on your real system (after testing, of course! 😉):


bash
git clone [https://github.com/FPGArtktktic/setup-DotFiles.git](https://github.com/FPGArtktktic/setup-DotFiles.git)
cd setup-DotFiles
./setup-dotFile.sh

The script is interactive, but you can also use flags like --yes to skip prompts or --dry-run to see what it would do!
Contribute & Customize!

This project is licensed under GNU GPLv3, meaning it's completely open for you to fork, adapt, and improve!

    Do you have a favorite tool that's missing?
    A better way to configure something?
    Want to add support for another distro?

Fork it, open a pull request, or just use it as a starting point for your own ultimate dotfiles!

You can find the repository here: https://github.com/FPGArtktktic/setup-DotFiles (Remember to update the link to your actual GitHub repo!)
Let me know what you think!

What are your biggest pain points when setting up a new dev environment? How do you automate your processes? Share your thoughts in the comments!

https://github.com/FPGArtktic/setup-DotFiles

Happy automating! ✨

GnuRAMage - automated approach to RAM discs

Mateusz Okulanis — Fri, 30 May 2025 18:37:31 +0000

🚀 Introducing GnuRAMage: Sync Your HDDs to Blazing-Fast RAM Disks (and Keep Your Sanity!)

Ever dreamed of using multi-terabyte RAM disks for ludicrous speed but shuddered at the thought of data loss during a power flicker or the dreaded cat-on-keyboard scenario? 🙀

Meet GnuRAMage, a sophisticated (yet humble!) Bash tool designed to bridge the gap between your "sluggish rotating rust" (HDDs) and "blazing fast silicon heaven" (RAM disks). Think of it as your tireless digital intern, ensuring your frequently accessed files are always on the fast track while being safely backed up.

The Problem: Terabytes of RAM, Tons of Risk

You've got the RAM – maybe even terabytes of shiny DDR5. You want speed. But RAM is volatile. Without a robust sync strategy, that expensive RAM disk is a ticking time bomb for your data. Manual syncing? Ain't nobody got time for that, especially when dealing with huge datasets.

The Solution: GnuRAMage to the Rescue! 🛡️

GnuRAMage acts as your faithful guardian:

Copies files to RAM disk: For that sweet, sweet speed.
Periodically syncs back: Changes are regularly saved to persistent storage.
Protects your data: From power outages, crashes, and feline sabotage.
Peace of mind: Lets you leverage that RAM investment without the anxiety.

✨ Key Features That'll Make You Smile

GnuRAMage isn't just a one-trick pony. It's packed with features:

🧠 Automatic File Copying: Intelligently moves files from HDD to RAM disk.
⏱️ Periodic Synchronization: Regular, configurable sync-back to your HDD.
🚫 Exclusion Patterns: Don't want your node_modules or *.tmp files hogging precious RAM? No problem!
⚙️ INI Configuration: Human-readable and easy to set up.
📝 Comprehensive Logging: Multiple log levels, because knowing is half the battle.
🧪 Dry Run Mode: Test your setup without actually moving anything. Perfect for the cautious.
💨 One-time Mode: For those quick, single sync needs.
** gracefully Signal Handling:** Shuts down gracefully, ensuring a final sync.
🔐 Checksum Verification: Optional data integrity checks for the truly paranoid (we get it).
📜 Script Generation: Creates standalone scripts for easy automation with cron or systemd timers.

⚙️ How GnuRAMage Works: The Process

Under the hood, GnuRAMage follows a clear lifecycle:

Initialization: Parses your configuration (GnuRAMage.ini), checks for dependencies (like rsync), and validates the paths you've provided.
Initial Copy: Performs the first big lift – copying your specified files and directories from the slow source storage to the fast RAM disk.
Monitoring Loop: This is where the ongoing magic happens. GnuRAMage periodically (based on sync_interval) rsyncs any changes made on the RAM disk back to your persistent source storage.
Graceful Shutdown: If you interrupt GnuRAMage (e.g., with Ctrl+C), it aims to perform one final synchronization to ensure recent changes are saved before it exits.

The GNU Way filosofia

True to the GNU spirit, GnuRAMage is:

Free (as in freedom): Use it, share it, modify it.
Extensible: Tinker to your heart's content.
Well-documented: We try our best!

🛠️ Quick Start (The Traditional Way)

Clone the repository:

git clone git@github.com:FPGArtktic/GnuRAMage.git
cd GnuRAMage

Make it executable:
```
chmod +x gramage.sh
```

Configure it:
Copy GnuRAMage.ini.example to GnuRAMage.ini and edit it to match your setup:

cp GnuRAMage.ini.example GnuRAMage.ini
# Now edit GnuRAMage.ini with your favorite editor
# For example: nano GnuRAMage.ini

Your GnuRAMage.ini should look something like this:

[SETTINGS]
sync_interval = 180 # Sync every 3 minutes
log_level = INFO
verify_checksums = false

[DIRECTORIES]
source_dir = /mnt/my_hdd/important_data # Your persistent storage
ramdisk_dir = /mnt/ramdisk # Your blazing-fast RAM disk

[EXCLUDE]
*.bak
*.tmp
# Add other patterns as needed

Run it!
```
./gramage.sh
```
For a test drive (highly recommended first!):
```
./gramage.sh --dry-run --verbose
```

🤔 Who's This For?

Sysadmins managing large datasets.
Developers working with build systems or databases that benefit from fast I/O.
Data scientists crunching numbers on large files.
Anyone with a beefy RAM disk who wants to use it safely and efficiently!

💬 Want to Know More or Contribute?

Dive into the GitHub repository for the full README, including more on:

Detailed Usage & All CLI Options
Comprehensive Testing Suite
Troubleshooting Tips
How to Contribute (PRs welcome!)
Future Enhancements

GnuRAMage was born from a real need by Mateusz Okulanis (FPGArtktic). Let's make RAM disks both fast and reliable!

What are your strategies for managing large RAM disks? Share your thoughts below! 👇

bash #linux #sysadmin #ramdisk #performance #opensource #gnu #datasync

AutoGit-o-Matic: Your Git Sync Sidekick

Mateusz Okulanis — Thu, 29 May 2025 09:38:18 +0000

Hey there, dev.to community!

I'm excited to share my latest project with you: AutoGit-o-Matic (https://github.com/FPGArtktic/AutoGit-o-Matic). It's a straightforward yet powerful tool designed to automate core Git operations in your local repositories. I originally built this software for my own needs, stemming from two key scenarios.

The Genesis of AutoGit-o-Matic
Privately, I often work on personal projects across three different laptops. Manually pulling changes on each machine was a constant hassle and often led to me forgetting to sync. In my professional life, I needed a simple backup solution for testing environments where a full-blown CI/CD pipeline wasn't necessary or feasible. These experiences made me realize there had to be a better way to keep things synchronized and backed up, and AutoGit-o-Matic is my answer.

Key Benefits and Use Cases:
Effortless Git Repository Synchronization Across Multiple Machines: If you work on the same project across a laptop, desktop, or even several other machines, AutoGit-o-Matic can help keep all your repositories perfectly in sync. No more manual git pull every time you switch devices! Your repos will always be up-to-date.

Simple Project Backup for Small Businesses/Teams: For small businesses, freelancers, or compact teams without a centralized CI/CD system, AutoGit-o-Matic can serve as a simple and effective tool for automatically fetching the latest changes from your remote repository. This ensures everyone is working with the most current version of the code, minimizing the risk of data loss and streamlining collaboration.

How It Works:
AutoGit-o-Matic monitors specified local repositories and automatically performs Git operations (fetch and pull) at defined intervals. Configuration is designed to be simple and intuitive.

I'd Love to Hear Your Feedback!
I'm really keen to hear your thoughts and suggestions. Do you see other potential uses for AutoGit-o-Matic? What could be improved?

Feel free to test it out, report any issues, and submit pull requests on GitHub!

Thanks for your time!