Last year I created an rsync tool for myself. In short, It's purpose was to build rsync commands within a config file and use those files to build and run rsync commands. I preferred this over the every growing list of rsync commands I was experiencing. Making aliases for everything and keeping commands unified and neat was becoming overwhelming for myself.

Recently I've been sick so I used my free time to completely rewrite the script using all the knowledge I've learned over the last year writing some other scripts. I took out some features that were too specific, made the code much cleaner and easier to maintain and made the visual output easier to read and understand.

The script has a number of additional features including:

• Running multiple config files from a single command
• The base command will do a dry run to allow you to preview changes before committing to a transfer
• An option to quickly do a dry run to simply view any changes
• An option to quickly reverse the source/destination transfer direction
• An option to ignore the dry run and instantly perform a sync
• The ability to create a template config file that's (hopefully) easy to read and fill out
• Feedback for a number of common issues so that the rsync command will not run, hopefully avoiding any data loss issues
• An option to print out the full rsync command built from a config file (sometimes I want to move a specific file without creating a new, one time use config file)
• Built with ssh and ssh key files in mind
• Single file and POSIX portable with rsync as it's only dependency
• Long command option names for easier scripting

One notable change I made from my first script and the rewrite was using the sed command to gather information from the config files instead of directly sourcing into the main script. It's slightly less efficient but more secure than accidentally running commands while using the source (.) command. I'm still trying to figure out how to make it slightly more efficient but for now it works how I like it to work.

I've had such terrible luck with fully featured syncing programs (Syncthing for example) and have always had much better consistency with rsync (at the loss of bi-directional, continuous syncing). I also hated building rsync commands so this tool has been a great compromise for myself.

Hey everyone! After week of work finally rewrote dsci runner on golang.

git clone https://github.com/melezhik/dsci-runner.git cd dsci-runner go mod tidy go build -o dsci_runner main.go ./dsci_runner

That means just a single binary install Check it out ! )

Forgejo integrations details are here - http://deadsimpleci.sparrowhub.io/doc/forgejo-setup

LSS: I just wanna beable to slap together dirt simple datapipelines and iterate over them with new work. Currently I need it for like 3 things: a super special project I'm not ready to share yet, transcribing video chats, and generally webscraping (wget and curl are so reliable and comfy).

Claude fucked up pretty much everywhere that was important. To me programming is the practice of communicating your perfect and (ideally) edgecase-free understanding of how to solve a problem. I didn't know how to build a CI/snakemake styled datapipeline so I asked AI to help. As far as I understand, the task was too abstract, it had no idea what I wanted bc I had little idea of what I wanted. AI cannot replace a programmer when brand new abstractions need to be invented!!

I am happy to finally have this tool and cannot wait to implement it in my daily workflows.

I made this to help my partner with her WFH setup.

Some of her cameras will over-expose when left on auto, and the settings to tweak the exposure aren't super easy to get to.

With this tool, we have bound the spare knobs on her macropad (https://www.aliexpress.com/item/1005003500083583.html) to increase/decrease the exposure easily.

Disclosure: I used AI for the initial draft of the Windows api, and also to generate the README. Both have been manually reviewed and extensively refactored, although I am sure that there are some AI-isms that I probably missed (or accepted).

The Script

While researching and learning different tasks to do for my personal scripts, I tried keeping my code examples in different files in a directory. It was very unorganized and a bit overwhelming to deal. Instead I started writing a script that functions as a library for all the things I have learned.

The script keeps everything in one spot and it's much easier to work on it. It also acts as a functioning style guide for myself so I can standardize my own future scripts. It's also easy to add code or work on existing code. I usually have it open whenever I am writing something new to use as a quick reference guide.

Some of the features I have worked on include:

• Making it easier to use POSIX getopts. I can easily add long options. I also made it simple for me to process arguments or deal with conflicting options.
• Working with simple "arrays" (positional parameters). There's a nice little function that can save the array to a variable which can then be set again to be used in different parts of the script.
• a Yes/No confirmation function which can accept a y or n character instantly without pressing enter to proceed.
• A few of examples extracting data from variables using variable expansions
• An enter password function that works similar to the read -rscommand
• A couple examples of using the trap command to help reset changes made during a script

I tried my best to make it easy and obvious to understand. I know future me would get annoyed trying to relearn something I worked on before when I am focused on the script I want to write currently.

I'm learning more about the very basic commands of Linux which is why I prefer writing POSIX portable scripts over Bash scripts. Deconstructing read -rs is a good example. I got to play around with the stty command and learn a couple things about terminal settings.

It's a nice, simple and ongoing project. Maybe there is something useful in there for anyone else writing POSIX portable scripts. I would like to learn a little about awk and sed in the future but I haven't found a project yet where that can be used.

Last year while I was learning to self-host some services on a Raspberry Pi I came across Alpine Linux. The very minimal environment of Alpine Linux was something that really interested me. Somewhere along the way I started writing scripts. Since Bash wasn't my default shell and I was missing a lot of other programs that would normally be pre-installed under other distributions, I unintentionally started writing POSIX portable scripts.

I continued writing with POSIX in mind because I not only found it interesting but it was also giving me a better understanding of how Linux works under the hood. I was always curious about how windows worked when I was using it but it always seemed so much more complex and intimidating.

This specific script I wrote was meant to make mounting and unmounting a LUKS encrypted device from the command line easier and a bit safer. Eventually I extended the functionality to automatically decrypt, mount, execute a command, unmount and reencrypt the device in one single command.

My reasoning for this is because I use external encrypted USB drives to backup my computer, phone and two RPi devices. I wanted to still enter my passphrase but I didn't want to forget to reencrypt my device after updating the backup.

Some of the things I learned while writing this script in particular was working with getopts and changing terminal settings with stty. There are a bunch of other small things I learned to work around the limited tools I had available but it would be too much to try and list them all.

With getopts I managed to find a few ways to make it manageable and easy to work with long options. That makes it much easier to use this script within other scripts since I don't have to remember what each single character short option name does. The limitation with getopts and long option names is that the long option requires an '=' character but it works consistently which is what matters to me.

With stty I learned how to disable and reenable job control (default CTRL+Z in a terminal) as a way to prevent the script from being interrupted and leaving the device unencrypted because the script couldn't continue with the unmounting trap command.

I spent a couple months of my free time working on this script but it's at the point where I am comfortable and very happy with how it turned out. It's a single file, POSIX portable and only requires cryptsetup as it's only dependency.

I'll apologize for the commenting in advance, I find the shouty comments help me understand what's happening with the script better than trying to remember what each command or variable does. It's also might seem silly in some places but it's consistent which is also important to me.

The Script: emountman

Just wanted to share this stupid little python script I wrote forever ago.

I used way too much pythonic syntax just to make the caps lock and scroll lock lights on my old keyboard flash like the lights next to the network socket. I don't really use that keyboard anymore but I remember how excited I was to see for the first time when I write something to a file using vim or vs code or my own scripts to make something physical happen.

I very much believe the world needs more DSLs for doing traditionally-point-and-click-adventure kind of operations in an easily auditable, reproducible, parameterized, precise, and programmatic way.

This is my first significant project in service of being the change I want to see in the world. (It's a few years old at this point, but I wanted to show/tell it anyway.) It's a DSL for making simple web comics and story boards.

This is a "scratch my own itch" kind of project. I was GM'ing a 5e game and I do my notes digitally. I have a system for managing my GM'ing notes in digital form that translates extended-syntax Markdown into HTML pages for me to reference at the table. (Yes I should open-source that as well, but I haven't gotten to it yet.) And my brain absorbs a story board way quicker than text. So I wrote codecomic and added some code to my GM notes system to let me just embed codecomic source code in the markdown such that it would render the comics to images and embed them in the HTML. That all took me from "ok, hold on everybody while I read the next paragraph of dense text about what's going down over the next 5 seconds of in-game time" to getting all the same information at a glance. (I still had bulleted lists of more reference information surrounding the story boards, but the story boards really improved the flow of the game.)

Go is my (no pun intended) go-to language for most things lately, and codecomic is written in Go. (I don't know quite what to call the codecomic program. "Interpreter"? "Runtime"? "Engine"? "Processor"? Maybe just "program".)

Hey! I am building a brand new CI based on top of forgejo/gitea - the thing is to use general purpose programming languages instead of YAML for pipelines. So I have launched a forgejo instance with DSCI runner integrated, where you can find some example pipelines for demo projects - http://forgejo.sparrowhub.io/root

So I am looking for beta testers, anyone who wants to try out the dsci - please let me know - so I will create an account for you ( you may find the link to the discord channel at the web site ) and you will start to create and run pipelines for projects you like

I was working on another random side project and wanted to define configs like Pydantic-Settings without actually pulling in all of Pydantic into my project, so I started writing a custom config class which turned out generic enough that I could break it off into its own thing.

One of the main things I wanted is to be able to load a TOML file for settings but to also be able to override each config option with an env var. I also really like Pydantic's use of Annotation[..., ...] type-hinting so I did something similar

I don't really expect it to be used by anyone else but I'm excited about putting out my first PyPi package and figured I'd share it here :)

Any feedback is very welcome!

PyPi link: https://pypi.org/project/pymicroconf/

Also AI disclosure: I got AI to partially write the description but the code itself isn't written by AI

I bought this simple ass little macropad that uses real keyboard switches and for like a year I had no idea how to use it. There was no dirt simple file configed little command I can plant in my i3/config and be happy with it so I built it!

It was my first attempt at building a production-level thing out of rust and I'm really happy with it. Now I can finally use my goddamn macropad!!