From 24636ef8fc5fc11e878a11fb8ae821d8e7d0a269 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Wed, 9 Jul 2025 00:54:07 +0300 Subject: Update content for md --- about/index.md | 7 +- about/podcasts.txt | 1 + about/resources.md | 189 +- about/showcase.md | 2034 +++++ about/showcase/debroid/image-1.png | 1972 +++++ about/showcase/ds-sim/image-1.png | Bin 0 -> 139067 bytes about/showcase/dtail/image-1.png | Bin 0 -> 84933 bytes about/showcase/dtail/image-2.gif | Bin 0 -> 2290260 bytes about/showcase/gogios/image-1.png | Bin 0 -> 56698 bytes about/showcase/gos/image-1.png | Bin 0 -> 3861 bytes about/showcase/gos/image-2.png | Bin 0 -> 137561 bytes about/showcase/ior/image-1.png | Bin 0 -> 46683 bytes about/showcase/ior/image-2.svg | 12270 +++++++++++++++++++++++++++++++ about/showcase/ioriot/image-1.png | Bin 0 -> 12508 bytes about/showcase/jsmstrade/image-1.png | Bin 0 -> 13636 bytes about/showcase/netcalendar/image-1.png | Bin 0 -> 131869 bytes about/showcase/netcalendar/image-2.png | Bin 0 -> 217299 bytes about/showcase/quicklogger/image-1.png | Bin 0 -> 63314 bytes about/showcase/quicklogger/image-2.png | Bin 0 -> 13498 bytes about/showcase/tasksamurai/image-1.png | Bin 0 -> 227442 bytes about/showcase/tasksamurai/image-2.png | Bin 0 -> 1382480 bytes about/showcase/vs-sim/image-1.jpg | Bin 0 -> 214287 bytes 22 files changed, 16378 insertions(+), 95 deletions(-) create mode 100644 about/showcase.md create mode 100644 about/showcase/debroid/image-1.png create mode 100644 about/showcase/ds-sim/image-1.png create mode 100644 about/showcase/dtail/image-1.png create mode 100644 about/showcase/dtail/image-2.gif create mode 100644 about/showcase/gogios/image-1.png create mode 100644 about/showcase/gos/image-1.png create mode 100644 about/showcase/gos/image-2.png create mode 100644 about/showcase/ior/image-1.png create mode 100644 about/showcase/ior/image-2.svg create mode 100644 about/showcase/ioriot/image-1.png create mode 100644 about/showcase/jsmstrade/image-1.png create mode 100644 about/showcase/netcalendar/image-1.png create mode 100644 about/showcase/netcalendar/image-2.png create mode 100644 about/showcase/quicklogger/image-1.png create mode 100644 about/showcase/quicklogger/image-2.png create mode 100644 about/showcase/tasksamurai/image-1.png create mode 100644 about/showcase/tasksamurai/image-2.png create mode 100644 about/showcase/vs-sim/image-1.jpg (limited to 'about') diff --git a/about/index.md b/about/index.md index afd3bd6d..b0830c48 100644 --- a/about/index.md +++ b/about/index.md @@ -13,10 +13,15 @@ ## My sites [My blog here at foo.zone](../) -[codeberg.org/snonux - My Codeberg page](https://codeberg.org/snonux) [irregular.ninja - My street photography site (warn: multiple MBs, it's photos after all)](https://irregular.ninja) [DTail - the distributed log tailing program](./dtail.md) +## Show me the code + +[Project showcase](./showcase.md) +[codeberg.org/snonux - My Codeberg page](https://codeberg.org/snonux) +[github.com/snonux - My GitHub page (it's just a mirror of Codeberg, really)](https://github.com/snonux) + ## Social Media and Communities [@snonux@fosstodon.org - Me at Mastodon](https://fosstodon.org/@snonux) diff --git a/about/podcasts.txt b/about/podcasts.txt index c7c4ce9e..6d150936 100644 --- a/about/podcasts.txt +++ b/about/podcasts.txt @@ -4,6 +4,7 @@ * Cup o' Go [Golang] * Deep Questions with Cal Newport * Dev Interrupted +* Pratical AI * Fallthrough [Golang] * Hidden Brain * Maintainable diff --git a/about/resources.md b/about/resources.md index 79557ab7..0ce055c7 100644 --- a/about/resources.md +++ b/about/resources.md @@ -35,105 +35,105 @@ You won't find any links on this site because, over time, the links will break. In random order: +* Clusterbau mit Linux-HA; Michael Schwartzkopff; O'Reilly +* Learn You a Haskell for Great Good!; Miran Lipovaca; No Starch Press +* Data Science at the Command Line; Jeroen Janssens; O'Reilly +* Effective Java; Joshua Bloch; Addison-Wesley Professional +* Kubernetes Cookbook; Sameer Naik, Sébastien Goasguen, Jonathan Michaux; O'Reilly * Modern Perl; Chromatic ; Onyx Neon Press -* C++ Programming Language; Bjarne Stroustrup; +* Amazon Web Services in Action; Michael Wittig and Andreas Wittig; Manning Publications +* Higher Order Perl; Mark Dominus; Morgan Kaufmann * Learn You Some Erlang for Great Good; Fred Herbert; No Starch Press -* Funktionale Programmierung; Peter Pepper; Springer * Object-Oriented Programming with ANSI-C; Axel-Tobias Schreiner -* Leanring eBPF; Liz Rice; O'Reilly -* Effective awk programming; Arnold Robbins; O'Reilly -* Effective Java; Joshua Bloch; Addison-Wesley Professional -* The Practise of System and Network Administration; Thomas A. Limoncelli, Christina J. Hogan, Strata R. Chalup; Addison-Wesley Professional Pro Git; Scott Chacon, Ben Straub; Apress -* Raku Fundamentals; Moritz Lenz; Apress -* Think Raku (aka Think Perl 6); Laurent Rosenfeld, Allen B. Downey; O'Reilly -* Java ist auch eine Insel; Christian Ullenboom; -* Data Science at the Command Line; Jeroen Janssens; O'Reilly * Distributed Systems: Principles and Paradigms; Andrew S. Tanenbaum; Pearson -* Amazon Web Services in Action; Michael Wittig and Andreas Wittig; Manning Publications -* Systems Performance Tuning; Gian-Paolo D. Musumeci and others...; O'Reilly -* DNS and BIND; Cricket Liu; O'Reilly -* Go Brain Teasers - Exercise Your Mind; Miki Tebeka; The Pragmatic Programmers -* DevOps And Site Reliability Engineering Handbook; Stephen Fleming; Audible -* Ultimate Go Notebook; Bill Kennedy -* Concurrency in Go; Katherine Cox-Buday; O'Reilly * Hands-on Infrastructure Monitoring with Prometheus; Joel Bastos, Pedro Araujo; Packt -* Learn You a Haskell for Great Good!; Miran Lipovaca; No Starch Press -* 97 things every SRE should know; Emil Stolarsky, Jaime Woo; O'Reilly -* Systemprogrammierung in Go; Frank Müller; dpunkt -* Tmux 2: Productive Mouse-free Development; Brain P. Hogan; The Pragmatic Programmers +* Programming Perl aka "The Camel Book"; Tom Christiansen, brian d foy, Larry Wall & Jon Orwant; O'Reilly +* The DevOps Handbook; Gene Kim, Jez Humble, Patrick Debois, John Willis; Audible * Developing Games in Java; David Brackeen and others...; New Riders -* The Kubernetes Book; Nigel Poulton; Unabridged Audiobook -* Programming Ruby 3.3 (5th Edition); Noel Rappin, with Dave Thomas; The Pragmatic Bookshelf -* Clusterbau mit Linux-HA; Michael Schwartzkopff; O'Reilly -* Kubernetes Cookbook; Sameer Naik, Sébastien Goasguen, Jonathan Michaux; O'Reilly -* Raku Recipes; J.J. Merelo; Apress +* DNS and BIND; Cricket Liu; O'Reilly * The Docker Book; James Turnbull; Kindle +* Go Brain Teasers - Exercise Your Mind; Miki Tebeka; The Pragmatic Programmers * Terraform Cookbook; Mikael Krief; Packt Publishing -* Programming Perl aka "The Camel Book"; Tom Christiansen, brian d foy, Larry Wall & Jon Orwant; O'Reilly -* The Pragmatic Programmer; David Thomas; Addison-Wesley -* The KCNA (Kubernetes and Cloud Native Associate) Book; Nigel Poulton -* Higher Order Perl; Mark Dominus; Morgan Kaufmann -* Polished Ruby Programming; Jeremy Evans; Packt Publishing -* 100 Go Mistakes and How to Avoid Them; Teiva Harsanyi; Manning Publications -* Site Reliability Engineering; How Google runs production systems; O'Reilly -* 21st Century C: C Tips from the New School; Ben Klemens; O'Reilly * The Go Programming Language; Alan A. A. Donovan; Addison-Wesley Professional -* The DevOps Handbook; Gene Kim, Jez Humble, Patrick Debois, John Willis; Audible +* Funktionale Programmierung; Peter Pepper; Springer +* 100 Go Mistakes and How to Avoid Them; Teiva Harsanyi; Manning Publications +* Leanring eBPF; Liz Rice; O'Reilly * Pro Puppet; James Turnbull, Jeffrey McCune; Apress +* Polished Ruby Programming; Jeremy Evans; Packt Publishing +* Ultimate Go Notebook; Bill Kennedy * Perl New Features; Joshua McAdams, brian d foy; Perl School +* Programming Ruby 3.3 (5th Edition); Noel Rappin, with Dave Thomas; The Pragmatic Bookshelf +* Raku Recipes; J.J. Merelo; Apress +* The Kubernetes Book; Nigel Poulton; Unabridged Audiobook +* Effective awk programming; Arnold Robbins; O'Reilly +* DevOps And Site Reliability Engineering Handbook; Stephen Fleming; Audible +* Tmux 2: Productive Mouse-free Development; Brain P. Hogan; The Pragmatic Programmers +* Systems Performance Tuning; Gian-Paolo D. Musumeci and others...; O'Reilly +* Java ist auch eine Insel; Christian Ullenboom; +* Concurrency in Go; Katherine Cox-Buday; O'Reilly +* Systemprogrammierung in Go; Frank Müller; dpunkt +* The KCNA (Kubernetes and Cloud Native Associate) Book; Nigel Poulton +* Think Raku (aka Think Perl 6); Laurent Rosenfeld, Allen B. Downey; O'Reilly +* 97 things every SRE should know; Emil Stolarsky, Jaime Woo; O'Reilly +* The Pragmatic Programmer; David Thomas; Addison-Wesley +* 21st Century C: C Tips from the New School; Ben Klemens; O'Reilly +* Site Reliability Engineering; How Google runs production systems; O'Reilly +* C++ Programming Language; Bjarne Stroustrup; +* The Practise of System and Network Administration; Thomas A. Limoncelli, Christina J. Hogan, Strata R. Chalup; Addison-Wesley Professional Pro Git; Scott Chacon, Ben Straub; Apress +* Raku Fundamentals; Moritz Lenz; Apress ## Technical references I didn't read them from the beginning to the end, but I am using them to look up things. The books are in random order: +* Relayd and Httpd Mastery; Michael W Lucas * Groovy Kurz & Gut; Joerg Staudemeier; O'Reilly -* The Linux Programming Interface; Michael Kerrisk; No Starch Press -* Go: Design Patterns for Real-World Projects; Mat Ryer; Packt -* Understanding the Linux Kernel; Daniel P. Bovet, Marco Cesati; O'Reilly * Implementing Service Level Objectives; Alex Hidalgo; O'Reilly +* Go: Design Patterns for Real-World Projects; Mat Ryer; Packt * Algorithms; Robert Sedgewick, Kevin Wayne; Addison Wesley -* Relayd and Httpd Mastery; Michael W Lucas * BPF Performance Tools - Linux System and Application Observability, Brendan Gregg; Addison Wesley +* Understanding the Linux Kernel; Daniel P. Bovet, Marco Cesati; O'Reilly +* The Linux Programming Interface; Michael Kerrisk; No Starch Press ## Self-development and soft-skills books In random order: -* The Off Switch; Mark Cropley; Virgin Books (RE-READ 1ST TIME) -* The Power of Now; Eckhard Tolle; Yellow Kite -* 101 Essays that change the way you think; Brianna Wiest; Audiobook -* Digital Minimalism; Cal Newport; Portofolio Penguin -* Eat That Frog; Brian Tracy +* Search Inside Yourself - The Unexpected path to Achieving Success, Happiness (and World Peace); Chade-Meng Tan, Daniel Goleman, Jon Kabat-Zinn; HarperOne * Consciousness: A Very Short Introduction; Susan Blackmore; Oxford Uiversity Press -* Never Split the Difference; Chris Voss, Tahl Raz; Random House Business -* Getting Things Done; David Allen +* Stop starting, start finishing; Arne Roock; Lean-Kanban University +* Influence without Authority; A. Cohen, D. Bradford; Wiley * Eat That Frog!; Brian Tracy; Hodder Paperbacks +* Time Management for System Administrators; Thomas A. Limoncelli; O'Reilly +* Slow Productivity; Cal Newport; Penguin Random House +* Psycho-Cybernetics; Maxwell Maltz; Perigee Books +* Ultralearning; Scott Young; Thorsons +* Digital Minimalism; Cal Newport; Portofolio Penguin * Buddah and Einstein walk into a Bar; Guy Joseph Ale, Claire Bloom; Blackstone Publishing -* The Obstacle Is The Way; Ryan Holiday; Profile Books Ltd -* Staff Engineer: Leadership beyond the management track; Will Larson; Audiobook -* Search Inside Yourself - The Unexpected path to Achieving Success, Happiness (and World Peace); Chade-Meng Tan, Daniel Goleman, Jon Kabat-Zinn; HarperOne -* Coders at Work - Reflections on the craft of programming, Peter Seibel and Mitchell Dorian et al., Audiobook -* The Daily Stoic; Ryan Holiday, Stephen Hanselman; Profile Books -* Ultralearning; Anna Laurent; Self-published via Amazon -* The Phoenix Project - A Novel About IT, DevOps, and Helping your Business Win; Gene Kim and Kevin Behr; Trade Select -* So Good They Can't Ignore You; Cal Newport; Business Plus -* Deep Work; Cal Newport; Piatkus -* The Bullet Journal Method; Ryder Carroll; Fourth Estate -* The Good Enough Job; Simone Stolzoff; Ebury Edge -* Who Moved My Cheese?; Dr. Spencer Johnson; Vermilion * The Complete Software Developer's Career Guide; John Sonmez; Unabridged Audiobook +* 101 Essays that change the way you think; Brianna Wiest; Audiobook * Soft Skills; John Sommez; Manning Publications -* Ultralearning; Scott Young; Thorsons -* The 7 Habits Of Highly Effective People; Stephen R. Covey; Simon & Schuster UK -* Time Management for System Administrators; Thomas A. Limoncelli; O'Reilly -* Solve for Happy; Mo Gawdat (RE-READ 1ST TIME) -* Slow Productivity; Cal Newport; Penguin Random House * The Joy of Missing Out; Christina Crook; New Society Publishers -* Psycho-Cybernetics; Maxwell Maltz; Perigee Books +* The Off Switch; Mark Cropley; Virgin Books (RE-READ 1ST TIME) +* Who Moved My Cheese?; Dr. Spencer Johnson; Vermilion +* Staff Engineer: Leadership beyond the management track; Will Larson; Audiobook +* Ultralearning; Anna Laurent; Self-published via Amazon * Atomic Habits; James Clear; Random House Business +* The Obstacle Is The Way; Ryan Holiday; Profile Books Ltd +* The Good Enough Job; Simone Stolzoff; Ebury Edge +* The Bullet Journal Method; Ryder Carroll; Fourth Estate +* The 7 Habits Of Highly Effective People; Stephen R. Covey; Simon & Schuster UK +* Eat That Frog; Brian Tracy +* Getting Things Done; David Allen * Meditation for Mortals, Oliver Burkeman, Audiobook -* Influence without Authority; A. Cohen, D. Bradford; Wiley -* Stop starting, start finishing; Arne Roock; Lean-Kanban University +* The Phoenix Project - A Novel About IT, DevOps, and Helping your Business Win; Gene Kim and Kevin Behr; Trade Select +* Deep Work; Cal Newport; Piatkus +* Never Split the Difference; Chris Voss, Tahl Raz; Random House Business +* So Good They Can't Ignore You; Cal Newport; Business Plus +* The Daily Stoic; Ryan Holiday, Stephen Hanselman; Profile Books +* Coders at Work - Reflections on the craft of programming, Peter Seibel and Mitchell Dorian et al., Audiobook +* The Power of Now; Eckhard Tolle; Yellow Kite +* Solve for Happy; Mo Gawdat (RE-READ 1ST TIME) [Here are notes of mine for some of the books](../notes/index.md) @@ -141,22 +141,22 @@ In random order: Some of these were in-person with exams; others were online learning lectures only. In random order: -* Scripting Vim; Damian Conway; O'Reilly Online -* Cloud Operations on AWS - Learn how to configure, deploy, maintain, and troubleshoot your AWS environments; 3-day online live training with labs; Amazon -* Algorithms Video Lectures; Robert Sedgewick; O'Reilly Online * Apache Tomcat Best Practises; 3-day on-site training +* F5 Loadbalancers Training; 2-day on-site training; F5, Inc. * Red Hat Certified System Administrator; Course + certification (Although I had the option, I decided not to take the next course as it is more effective to self learn what I need) -* Structure and Interpretation of Computer Programs; Harold Abelson and more...; -* Ultimate Go Programming; Bill Kennedy; O'Reilly Online -* Functional programming lecture; Remote University of Hagen -* The Ultimate Kubernetes Bootcamp; School of Devops; O'Reilly Online * AWS Immersion Day; Amazon; 1-day interactive online training -* Protocol buffers; O'Reilly Online +* The Ultimate Kubernetes Bootcamp; School of Devops; O'Reilly Online +* MySQL Deep Dive Workshop; 2-day on-site training * Developing IaC with Terraform (with Live Lessons); O'Reilly Online * The Well-Grounded Rubyist Video Edition; David. A. Black; O'Reilly Online -* MySQL Deep Dive Workshop; 2-day on-site training +* Protocol buffers; O'Reilly Online +* Cloud Operations on AWS - Learn how to configure, deploy, maintain, and troubleshoot your AWS environments; 3-day online live training with labs; Amazon +* Structure and Interpretation of Computer Programs; Harold Abelson and more...; +* Functional programming lecture; Remote University of Hagen +* Scripting Vim; Damian Conway; O'Reilly Online * Linux Security and Isolation APIs Training; Michael Kerrisk; 3-day on-site training -* F5 Loadbalancers Training; 2-day on-site training; F5, Inc. +* Algorithms Video Lectures; Robert Sedgewick; O'Reilly Online +* Ultimate Go Programming; Bill Kennedy; O'Reilly Online ## Technical guides @@ -172,47 +172,48 @@ These are not whole books, but guides (smaller or larger) which I found very use In random order: -* Fork Around And Find Out -* BSD Now [BSD] * The Pragmatic Engineer Podcast +* Fallthrough [Golang] +* The Changelog Podcast(s) +* Backend Banter +* Maintainable * Modern Mentor -* Cup o' Go [Golang] * Dev Interrupted -* The Changelog Podcast(s) -* Deep Questions with Cal Newport +* BSD Now [BSD] * Hidden Brain -* Maintainable +* Deep Questions with Cal Newport * The ProdCast (Google SRE Podcast) -* Backend Banter -* Fallthrough [Golang] +* Pratical AI +* Cup o' Go [Golang] +* Fork Around And Find Out ### Podcasts I liked I liked them but am not listening to them anymore. The podcasts have either "finished" (no more episodes) or I stopped listening to them due to time constraints or a shift in my interests. -* FLOSS weekly +* Go Time (predecessor of fallthrough) * CRE: Chaosradio Express [german] +* FLOSS weekly * Java Pub House -* Ship It (predecessor of Fork Around And Find Out) * Modern Mentor -* Go Time (predecessor of fallthrough) +* Ship It (predecessor of Fork Around And Find Out) ## Newsletters I like This is a mix of tech and non-tech newsletters I am subscribed to. In random order: * The Valuable Dev -* Changelog News +* VK Newsletter * Monospace Mentor +* byteSizeGo * The Pragmatic Engineer -* Applied Go Weekly Newsletter -* Ruby Weekly -* Andreas Brandhorst Newsletter (Sci-Fi author) -* Golang Weekly -* VK Newsletter * The Imperfectionist -* byteSizeGo +* Changelog News +* Andreas Brandhorst Newsletter (Sci-Fi author) * Register Spill +* Ruby Weekly +* Applied Go Weekly Newsletter +* Golang Weekly ## Magazines I like(d) diff --git a/about/showcase.md b/about/showcase.md new file mode 100644 index 00000000..5590a68b --- /dev/null +++ b/about/showcase.md @@ -0,0 +1,2034 @@ +# Project Showcase + +Generated on: 2025-07-09 + +This page showcases my open source projects, providing an overview of what each project does, its technical implementation, and key metrics. Each project summary includes information about the programming languages used, development activity, and licensing. The projects are ordered by recent activity, with the most actively maintained projects listed first. + +## Table of Contents + +* [⇢ Project Showcase](#project-showcase) +* [⇢ ⇢ Overall Statistics](#overall-statistics) +* [⇢ ⇢ Projects](#projects) +* [⇢ ⇢ ⇢ gitsyncer](#gitsyncer) +* [⇢ ⇢ ⇢ timr](#timr) +* [⇢ ⇢ ⇢ tasksamurai](#tasksamurai) +* [⇢ ⇢ ⇢ rexfiles](#rexfiles) +* [⇢ ⇢ ⇢ foo.zone](#foozone) +* [⇢ ⇢ ⇢ dtail](#dtail) +* [⇢ ⇢ ⇢ wireguardmeshgenerator](#wireguardmeshgenerator) +* [⇢ ⇢ ⇢ ior](#ior) +* [⇢ ⇢ ⇢ ds-sim](#ds-sim) +* [⇢ ⇢ ⇢ sillybench](#sillybench) +* [⇢ ⇢ ⇢ gos](#gos) +* [⇢ ⇢ ⇢ foostats](#foostats) +* [⇢ ⇢ ⇢ rcm](#rcm) +* [⇢ ⇢ ⇢ gemtexter](#gemtexter) +* [⇢ ⇢ ⇢ quicklogger](#quicklogger) +* [⇢ ⇢ ⇢ docker-gpodder-sync-server](#docker-gpodder-sync-server) +* [⇢ ⇢ ⇢ terraform](#terraform) +* [⇢ ⇢ ⇢ gogios](#gogios) +* [⇢ ⇢ ⇢ docker-radicale-server](#docker-radicale-server) +* [⇢ ⇢ ⇢ docker-anki-sync-server](#docker-anki-sync-server) +* [⇢ ⇢ ⇢ gorum](#gorum) +* [⇢ ⇢ ⇢ randomjournalpage](#randomjournalpage) +* [⇢ ⇢ ⇢ sway-autorotate](#sway-autorotate) +* [⇢ ⇢ ⇢ photoalbum](#photoalbum) +* [⇢ ⇢ ⇢ algorithms](#algorithms) +* [⇢ ⇢ ⇢ geheim](#geheim) +* [⇢ ⇢ ⇢ perl-c-fibonacci](#perl-c-fibonacci) +* [⇢ ⇢ ⇢ guprecords](#guprecords) +* [⇢ ⇢ ⇢ ioriot](#ioriot) +* [⇢ ⇢ ⇢ staticfarm-apache-handlers](#staticfarm-apache-handlers) +* [⇢ ⇢ ⇢ dyndns](#dyndns) +* [⇢ ⇢ ⇢ mon](#mon) +* [⇢ ⇢ ⇢ rubyfy](#rubyfy) +* [⇢ ⇢ ⇢ pingdomfetch](#pingdomfetch) +* [⇢ ⇢ ⇢ gotop](#gotop) +* [⇢ ⇢ ⇢ xerl](#xerl) +* [⇢ ⇢ ⇢ debroid](#debroid) +* [⇢ ⇢ ⇢ fapi](#fapi) +* [⇢ ⇢ ⇢ template](#template) +* [⇢ ⇢ ⇢ muttdelay](#muttdelay) +* [⇢ ⇢ ⇢ netdiff](#netdiff) +* [⇢ ⇢ ⇢ pwgrep](#pwgrep) +* [⇢ ⇢ ⇢ japi](#japi) +* [⇢ ⇢ ⇢ perl-poetry](#perl-poetry) +* [⇢ ⇢ ⇢ ipv6test](#ipv6test) +* [⇢ ⇢ ⇢ cpuinfo](#cpuinfo) +* [⇢ ⇢ ⇢ loadbars](#loadbars) +* [⇢ ⇢ ⇢ perldaemon](#perldaemon) +* [⇢ ⇢ ⇢ awksite](#awksite) +* [⇢ ⇢ ⇢ jsmstrade](#jsmstrade) +* [⇢ ⇢ ⇢ netcalendar](#netcalendar) +* [⇢ ⇢ ⇢ hsbot](#hsbot) +* [⇢ ⇢ ⇢ ychat](#ychat) +* [⇢ ⇢ ⇢ vs-sim](#vs-sim) +* [⇢ ⇢ ⇢ fype](#fype) + +## Overall Statistics + +* 📦 Total Projects: 55 +* 📊 Total Commits: 10,379 +* 📈 Total Lines of Code: 252,969 +* 📄 Total Lines of Documentation: 24,167 +* 💻 Languages: Java (22.4%), Go (17.6%), HTML (14.0%), C++ (8.9%), C (7.3%), Perl (6.3%), Shell (6.3%), C/C++ (5.8%), XML (4.6%), Config (1.5%), Ruby (1.1%), HCL (1.1%), Make (0.7%), Python (0.6%), CSS (0.6%), JSON (0.3%), Raku (0.3%), Haskell (0.2%), YAML (0.2%), TOML (0.1%) +* 📚 Documentation: Text (47.4%), Markdown (38.4%), LaTeX (14.2%) +* 🤖 AI-Assisted Projects: 8 out of 55 (14.5% AI-assisted, 85.5% human-only) +* 🚀 Release Status: 31 released, 24 experimental (56.4% with releases, 43.6% experimental) + +## Projects + +### gitsyncer + +* 💻 Languages: Go (86.0%), Shell (11.9%), YAML (1.5%), JSON (0.5%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 56 +* 📈 Lines of Code: 6241 +* 📄 Lines of Documentation: 2306 +* 📅 Development Period: 2025-06-23 to 2025-07-09 +* 🔥 Recent Activity: 4.2 days (avg. age of last 42 commits) +* ⚖️ License: BSD-2-Clause +* 🏷️ Latest Release: v0.4.0 (2025-07-09) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +GitSyncer is a cross-platform repository synchronization tool that automatically keeps Git repositories in sync across multiple hosting platforms like GitHub, Codeberg, and private SSH servers. It solves the common problem of maintaining consistent code across different Git hosting services by cloning repositories, adding all configured platforms as remotes, and continuously merging and pushing changes bidirectionally while handling branch creation and conflict detection. + +The tool is implemented in Go with a clean architecture that supports both individual repository syncing and bulk operations for public repositories. Key features include automatic repository creation, SSH backup locations for private servers, branch exclusion patterns, and an opt-in backup mode for resilient offline backups. It uses a JSON configuration file to define organizations and repositories, employs safe merge strategies that never delete branches, and provides comprehensive error handling for merge conflicts and missing repositories. + +[View on Codeberg](https://codeberg.org/snonux/gitsyncer) +[View on GitHub](https://github.com/snonux/gitsyncer) + +Go from `internal/version/version.go`: + +```AUTO +var ( + Version = "0.4.0" + + GitCommit = "unknown" + + BuildDate = "unknown" +``` + +--- + +### timr + +* 💻 Languages: Go (98.3%), YAML (1.7%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 19 +* 📈 Lines of Code: 873 +* 📄 Lines of Documentation: 135 +* 📅 Development Period: 2025-06-25 to 2025-06-29 +* 🔥 Recent Activity: 12.3 days (avg. age of last 42 commits) +* ⚖️ License: BSD-2-Clause +* 🧪 Status: Experimental (no releases yet) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +`timr` is a minimalist command-line time tracking tool written in Go that provides a simple stopwatch-style timer for tracking work sessions. It offers commands to start, stop, reset, and check the status of the timer, with all state persisted across sessions in `~/.config/timr/.timr_state`. The tool is particularly useful for developers and professionals who need to track time spent on tasks without the overhead of complex time-tracking applications. + +The project is implemented using a clean modular architecture with the CLI entry point in `/cmd/timr/main.go`, core timer logic in `/internal/timer/`, and an interactive TUI mode powered by Bubble Tea in `/internal/live/`. Key features include persistent state across sessions, shell prompt integration for displaying timer status, raw output modes for scripting, and a full-screen live timer interface with keyboard controls. The tool maintains atomic state updates and handles unexpected exits gracefully by immediately persisting state changes. + +[View on Codeberg](https://codeberg.org/snonux/timr) +[View on GitHub](https://github.com/snonux/timr) + +Go from `internal/timer/operations.go`: + +```AUTO +func GetRawStatus() (string, error) { + state, err := LoadState() + if err != nil { + return "", fmt.Errorf("error loading state: %w", err) + } + + elapsed := state.ElapsedTime + if state.Running { + elapsed += time.Since(state.StartTime) + } + + return fmt.Sprintf("%d", int(elapsed.Seconds())), nil +} +``` + +--- + +### tasksamurai + +* 💻 Languages: Go (99.8%), YAML (0.2%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 215 +* 📈 Lines of Code: 6160 +* 📄 Lines of Documentation: 162 +* 📅 Development Period: 2025-06-19 to 2025-07-08 +* 🔥 Recent Activity: 12.7 days (avg. age of last 42 commits) +* ⚖️ License: BSD-2-Clause +* 🏷️ Latest Release: v0.9.2 (2025-07-02) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +[![tasksamurai screenshot](showcase/tasksamurai/image-1.png "tasksamurai screenshot")](showcase/tasksamurai/image-1.png) + +TaskSamurai is a fast terminal user interface (TUI) for Taskwarrior written in Go that provides a keyboard-driven table interface for task management. It acts as a visual frontend to the Taskwarrior command-line tool, displaying tasks in a table format where users can perform operations like adding, completing, starting, and annotating tasks through hotkeys without leaving their keyboard. The application was created to provide a faster alternative to existing Python-based UIs while exploring the Bubble Tea framework for Go terminal applications. + +[![tasksamurai screenshot](showcase/tasksamurai/image-2.png "tasksamurai screenshot")](showcase/tasksamurai/image-2.png) + +The implementation follows a clean architecture with clear separation of concerns: the `internal/task/` package handles all Taskwarrior CLI integration by executing task commands and parsing JSON responses, while `internal/ui/` manages the terminal interface using Bubble Tea's message-driven architecture. The custom table widget in `internal/atable/` provides efficient rendering for large task lists, and the entire system maintains real-time synchronization with Taskwarrior by automatically refreshing the display after each operation. The application supports all standard Taskwarrior filters as command-line arguments and includes features like regex search, customizable themes, and even a "disco mode" that changes colors dynamically. + +[View on Codeberg](https://codeberg.org/snonux/tasksamurai) +[View on GitHub](https://github.com/snonux/tasksamurai) + +Go from `internal/ui/handlers.go`: + +```AUTO +func (m *Model) getTaskAtCursor() *task.Task { + cursor := m.tbl.Cursor() + if cursor < 0 || cursor >= len(m.tasks) { + return nil + } + return &m.tasks[cursor] +} +``` + +--- + +### rexfiles + +* 💻 Languages: Shell (34.8%), Perl (32.9%), Config (8.4%), CSS (8.3%), TOML (7.3%), Ruby (6.0%), Lua (1.8%), JSON (0.5%), INI (0.2%) +* 📚 Documentation: Text (97.3%), Markdown (2.7%) +* 📊 Commits: 871 +* 📈 Lines of Code: 3947 +* 📄 Lines of Documentation: 854 +* 📅 Development Period: 2021-12-28 to 2025-07-07 +* 🔥 Recent Activity: 20.0 days (avg. age of last 42 commits) +* ⚖️ License: No license found +* 🧪 Status: Experimental (no releases yet) + + +Based on my analysis of the codebase, **rexfiles** is a comprehensive infrastructure automation and configuration management project built with the Rex framework (a Perl-based alternative to Ansible, Puppet, or Chef). The project provides structured automation for managing multiple aspects of a personal infrastructure, including dotfiles, server configurations, and application deployments. + +The project consists of three main components: **dotfiles** management for personal development environment configuration (bash, fish shell, helix editor, tmux, etc.), **frontends** for managing production OpenBSD servers with services like DNS (nsd), web servers (httpd), mail (OpenSMTPD), SSL certificates (ACME), and monitoring systems, and **babylon5** containing Docker container startup scripts for self-hosted applications. The implementation leverages Rex's declarative syntax to define tasks for package installation, file management, service configuration, and system state management, with templates for configuration files and support for multiple operating systems (OpenBSD, FreeBSD, Fedora Linux, Termux). This approach provides a KISS (Keep It Simple, Stupid) alternative to more complex configuration management tools while maintaining the ability to manage both local development environments and production infrastructure consistently. + +[View on Codeberg](https://codeberg.org/snonux/rexfiles) +[View on GitHub](https://github.com/snonux/rexfiles) + +Shell from `frontends/scripts/sitestats.sh`: + +```AUTO +STATSFILE=/tmp/sitestats.csv +BOTSFILE=/tmp/sitebots.txt +TOP=20 +``` + +--- + +### foo.zone + +* 💻 Languages: HTML (73.9%), XML (25.9%), CSS (0.2%) +* 📚 Documentation: Text (91.8%), Markdown (8.2%) +* 📊 Commits: 2892 +* 📈 Lines of Code: 42772 +* 📄 Lines of Documentation: 159 +* 📅 Development Period: 2021-04-29 to 2025-07-01 +* 🔥 Recent Activity: 26.3 days (avg. age of last 42 commits) +* ⚖️ License: No license found +* 🧪 Status: Experimental (no releases yet) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +This is **foo.zone**, a personal blog and technical website belonging to Paul Buetow, a Site Reliability Engineer based in Sofia, Bulgaria. The project is a static website that serves as a comprehensive platform for sharing technical knowledge, book notes, and personal experiences in the fields of system administration, DevOps, and programming. + +The site is built using **Gemtexter**, a static site generator that creates both HTML and Gemini protocol content from markdown sources. The architecture is refreshingly simple and follows KISS principles, with content organized into several key sections: a main blog feed (gemfeed) with over 100 technical posts dating back to 2008, detailed book notes and summaries, project documentation (including tools like DTail for distributed log tailing), and personal resources. The website is served by OpenBSD using relayd and httpd, demonstrating the author's preference for robust, security-focused Unix systems. The project emphasizes clean, semantic HTML, custom CSS styling, and accessibility, while maintaining both web and Gemini protocol compatibility for broader reach across different internet communities. + +[View on Codeberg](https://codeberg.org/snonux/foo.zone) +[View on GitHub](https://github.com/snonux/foo.zone) + +HTML from `gemfeed/2022-01-23-welcome-to-the-foo.zone.html`: + +```AUTO + + + + +Welcome to the foo.zone + + + + + +``` + +--- + +### dtail + +* 💻 Languages: Go (93.9%), JSON (2.8%), C (2.0%), Make (0.5%), C/C++ (0.3%), Config (0.2%), Shell (0.2%), Docker (0.1%) +* 📚 Documentation: Text (79.4%), Markdown (20.6%) +* 📊 Commits: 1049 +* 📈 Lines of Code: 20091 +* 📄 Lines of Documentation: 5674 +* 📅 Development Period: 2020-01-09 to 2025-06-20 +* 🔥 Recent Activity: 51.8 days (avg. age of last 42 commits) +* ⚖️ License: Apache-2.0 +* 🏷️ Latest Release: v4.2.0 (2023-06-21) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +[![dtail screenshot](showcase/dtail/image-1.png "dtail screenshot")](showcase/dtail/image-1.png) + +DTail is a distributed log processing system written in Go that allows DevOps engineers to tail, cat, and grep log files across thousands of servers concurrently. It provides secure access through SSH authentication and respects UNIX file system permissions, making it ideal for enterprise environments where log analysis needs to scale horizontally across large server fleets. The tool supports advanced features like compressed file handling (gzip/zstd) and distributed MapReduce aggregations for complex log analytics. + +[![dtail screenshot](showcase/dtail/image-2.gif "dtail screenshot")](showcase/dtail/image-2.gif) + +The system uses a client-server architecture where dtail servers run on target machines (listening on port 2222) and clients connect to multiple servers simultaneously. It can also operate in serverless mode for local operations. The implementation leverages SSH for secure communication, includes sophisticated connection throttling and resource management, and provides specialized tools (dcat, dgrep, dmap) for different log processing tasks. The MapReduce functionality supports SQL-like queries with server-side local aggregation and client-side final aggregation, enabling powerful distributed analytics across log data. + +[View on Codeberg](https://codeberg.org/snonux/dtail) +[View on GitHub](https://github.com/snonux/dtail) + +Go from `internal/clients/baseclient.go`: + +```AUTO +func (c *baseClient) makeConnection(server string, sshAuthMethods []gossh.AuthMethod, + hostKeyCallback client.HostKeyCallback) connectors.Connector { + if c.Args.Serverless { + return connectors.NewServerless(c.UserName, c.maker.makeHandler(server), + c.maker.makeCommands()) + } + return connectors.NewServerConnection(server, c.UserName, sshAuthMethods, + hostKeyCallback, c.maker.makeHandler(server), c.maker.makeCommands()) +} +``` + +--- + +### wireguardmeshgenerator + +* 💻 Languages: Ruby (73.5%), YAML (26.5%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 33 +* 📈 Lines of Code: 396 +* 📄 Lines of Documentation: 24 +* 📅 Development Period: 2025-04-18 to 2025-05-11 +* 🔥 Recent Activity: 71.1 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🏷️ Latest Release: v1.0.0 (2025-05-11) + + +WireGuard Mesh Generator is a Ruby-based automation tool that simplifies the creation and management of WireGuard mesh VPN networks across multiple hosts. It automatically generates WireGuard configuration files for each node in the mesh, handles cryptographic key generation and management (including public/private keys and preshared keys), and provides automated deployment to remote machines via SSH/SCP. The tool is particularly useful for setting up secure, encrypted mesh networks between multiple servers or devices, eliminating the manual overhead of configuring WireGuard connections between every pair of nodes. + +The implementation uses a YAML configuration file to define the network topology, including host details, SSH credentials, and network addressing schemes. It supports mixed operating systems (FreeBSD, Linux, OpenBSD) with OS-specific configuration handling, intelligently determines network connectivity patterns (LAN vs internet-facing hosts), and includes features like NAT traversal detection and persistent keepalive configuration. The tool provides a complete workflow from key generation to deployment, making it ideal for infrastructure automation and maintaining consistent WireGuard mesh networks across diverse environments. + +[View on Codeberg](https://codeberg.org/snonux/wireguardmeshgenerator) +[View on GitHub](https://github.com/snonux/wireguardmeshgenerator) + +Ruby from `wireguardmeshgenerator.rb`: + +```AUTO +def priv = File.read(@privkey_path).strip + +def psk(peer) + psk_path = "#{@psk_dir}/#{[@myself, peer].sort.join('_')}.key" +``` + +--- + +### ior + +* 💻 Languages: C (54.7%), Go (37.4%), Raku (5.4%), Make (1.4%), C/C++ (1.1%) +* 📚 Documentation: Text (84.1%), Markdown (15.9%) +* 📊 Commits: 316 +* 📈 Lines of Code: 9835 +* 📄 Lines of Documentation: 559 +* 📅 Development Period: 2024-01-18 to 2025-06-14 +* 🔥 Recent Activity: 83.2 days (avg. age of last 42 commits) +* ⚖️ License: No license found +* 🧪 Status: Experimental (no releases yet) + + +[![ior screenshot](showcase/ior/image-1.png "ior screenshot")](showcase/ior/image-1.png) + +Based on my analysis of the codebase, here's a comprehensive summary of the I/O Riot NG (ior) project: + +[![ior screenshot](showcase/ior/image-2.svg "ior screenshot")](showcase/ior/image-2.svg) + +**I/O Riot NG** is a Linux-based performance monitoring tool that uses eBPF (extended Berkeley Packet Filter) to trace synchronous I/O system calls and analyze their execution times. This tool is particularly valuable for system performance analysis, allowing developers and system administrators to visualize I/O bottlenecks through detailed flamegraphs. It serves as a modern successor to the original I/O Riot project, migrating from SystemTap/C to a Go/C/BPF implementation for better performance and maintainability. + +The architecture combines kernel-level tracing with user-space analysis: eBPF programs (`internal/c/ior.bpf.c`) attach to kernel tracepoints to capture syscall entry/exit events, which are then processed by a Go-based event loop (`internal/eventloop.go`) that correlates enter/exit pairs, tracks file descriptors, and measures timing. The tool can operate in real-time mode for live monitoring or post-processing mode to generate flamegraphs from previously collected data using the Inferno flamegraph library. Key features include filtering capabilities for specific processes or file patterns, comprehensive statistics collection, and support for various I/O syscalls like open, read, write, close, and dup operations. + +[View on Codeberg](https://codeberg.org/snonux/ior) +[View on GitHub](https://github.com/snonux/ior) + +C from `internal/c/types.h`: + +```AUTO +struct open_event { + __u32 event_type; + __u32 trace_id; + __u64 time; + __u32 pid; + __u32 tid; + __s32 flags; + char filename[MAX_FILENAME_LENGTH]; + char comm[MAX_PROGNAME_LENGTH]; +}; +``` + +--- + +### ds-sim + +* 💻 Languages: Java (98.9%), Shell (0.6%), CSS (0.5%) +* 📚 Documentation: Markdown (98.7%), Text (1.3%) +* 📊 Commits: 438 +* 📈 Lines of Code: 25762 +* 📄 Lines of Documentation: 3101 +* 📅 Development Period: 2008-05-15 to 2025-06-27 +* 🔥 Recent Activity: 84.4 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🧪 Status: Experimental (no releases yet) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +[![ds-sim screenshot](showcase/ds-sim/image-1.png "ds-sim screenshot")](showcase/ds-sim/image-1.png) + +DS-Sim is an open-source Java-based simulator for distributed systems that provides a comprehensive environment for learning and experimenting with distributed algorithms. It features protocol simulation, event handling, and implementations of time concepts like Lamport and Vector timestamps. The simulator includes an interactive Swing GUI and comprehensive logging capabilities, making it particularly valuable for educational purposes and distributed systems research. + +The project is built on an event-driven architecture with clear component separation. At its core, VSSimulator drives the simulation loop with VSTaskManager executing time-ordered tasks, while VSAbstractProcess provides the foundation for simulation processes. The framework supports pluggable protocols through VSAbstractProtocol base classes, includes sophisticated time management with multiple clock types, and uses VSMessage objects for network communication simulation. The Maven-based architecture follows standard Java conventions and includes 141 unit tests covering core components like Two-Phase Commit, Berkeley Time synchronization, and PingPong protocols. + +[View on Codeberg](https://codeberg.org/snonux/ds-sim) +[View on GitHub](https://github.com/snonux/ds-sim) + +Java from `src/main/java/events/VSAbstractEvent.java`: + +```AUTO +public final void setClassname(String eventClassname) { + if (eventClassname.startsWith(CLASS_PREFIX)) + eventClassname = eventClassname.substring(CLASS_PREFIX_LENGTH); + + this.eventClassname = eventClassname; +} +``` + +--- + +### sillybench + +* 💻 Languages: Go (90.9%), Shell (9.1%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 5 +* 📈 Lines of Code: 33 +* 📄 Lines of Documentation: 3 +* 📅 Development Period: 2025-04-03 to 2025-04-03 +* 🔥 Recent Activity: 97.0 days (avg. age of last 42 commits) +* ⚖️ License: No license found +* 🧪 Status: Experimental (no releases yet) + + +**SillyBench** is a simple Go benchmarking project designed to compare CPU performance between FreeBSD and Linux Bhyve VM environments. The project implements basic mathematical operations (integer multiplication and floating-point arithmetic) to measure computational performance differences across different operating systems and virtualization setups. + +The implementation is minimal and focused, consisting of a basic Go module with two CPU-intensive benchmark functions: `BenchmarkCPUSilly1` performs simple integer squaring operations, while `BenchmarkCPUSilly2` executes more complex floating-point calculations involving addition, multiplication, and division. The project includes a simple shell script (`run.sh`) that executes the benchmarks using Go's built-in testing framework, making it easy to run consistent performance comparisons across different systems. + +[View on Codeberg](https://codeberg.org/snonux/sillybench) +[View on GitHub](https://github.com/snonux/sillybench) + +Go from `main.go`: + +```AUTO +func main() { + println("Hello world") +} +``` + +--- + +### gos + +* 💻 Languages: Go (98.6%), YAML (1.1%), JSON (0.2%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 381 +* 📈 Lines of Code: 3967 +* 📄 Lines of Documentation: 411 +* 📅 Development Period: 2024-05-04 to 2025-06-12 +* 🔥 Recent Activity: 113.9 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🏷️ Latest Release: v1.0.0 (2025-03-04) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +[![gos screenshot](showcase/gos/image-1.png "gos screenshot")](showcase/gos/image-1.png) + +Gos is a command-line social media scheduling tool written in Go that serves as a self-hosted replacement for Buffer.com. It allows users to create, queue, and schedule posts across multiple platforms (currently Mastodon, LinkedIn, and a "Noop" tracker platform) using a simple file-based approach. Users compose posts as text files in a designated directory (`~/.gosdir`), and can control posting behavior through filename tags (e.g., `share:mastodon`, `prio`, `now`) or inline tags within the content. + +[![gos screenshot](showcase/gos/image-2.png "gos screenshot")](showcase/gos/image-2.png) + +The tool is architected around a file-based queueing system where posts progress through lifecycle stages: `.txt` files are processed into platform-specific queues (`.queued` files), then marked as `.posted` after successful publishing. It features intelligent scheduling based on configurable targets (posts per week), pause periods between posts, priority handling, and OAuth2 authentication for LinkedIn. The system includes pause functionality for vacations, dry-run mode for testing, and can generate Gemini Gemtext summaries of posted content. Its design emphasizes automation, configurability, and integration into command-line workflows while maintaining a clean separation between platforms through a common interface. + +[View on Codeberg](https://codeberg.org/snonux/gos) +[View on GitHub](https://github.com/snonux/gos) + +Go from `internal/summary/summary.go`: + +```AUTO +func prepare(content string) string { + content = newlineRegex.ReplaceAllString(content, " ") + content = urlRegex.ReplaceAllString(content, "") + content = multiSpaceRegex.ReplaceAllString(content, " ") + content = strings.TrimSpace(content) + content = tagRegex.ReplaceAllString(content, "`$0`") + return content +} +``` + +--- + +### foostats + +* 💻 Languages: Perl (100.0%) +* 📚 Documentation: Markdown (85.1%), Text (14.9%) +* 📊 Commits: 67 +* 📈 Lines of Code: 1299 +* 📄 Lines of Documentation: 154 +* 📅 Development Period: 2023-01-02 to 2025-07-07 +* 🔥 Recent Activity: 133.5 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🧪 Status: Experimental (no releases yet) + + +Based on the README and project structure, **foostats** is a privacy-respecting web analytics tool written in Perl specifically designed for OpenBSD systems. It processes both traditional HTTP/HTTPS logs and Gemini protocol logs to generate comprehensive traffic statistics while maintaining visitor privacy through SHA3-512 IP hashing. The tool is built for the foo.zone ecosystem and similar sites that need analytics without compromising user privacy. + +The project implements a modular architecture with seven core components: FileHelper for I/O operations, DateHelper for date management, Logreader for log parsing, Filter for security filtering, Aggregator for statistics collection, FileOutputter for compressed JSON storage, Replicator for multi-node data sharing, Merger for combining statistics, and Reporter for generating human-readable Gemtext reports. It supports distributed deployments with replication between partner nodes and includes security features like suspicious request filtering based on configurable patterns (blocking common attack vectors like WordPress admin paths and PHP files). + +[View on Codeberg](https://codeberg.org/snonux/foostats) +[View on GitHub](https://github.com/snonux/foostats) + +Perl from `foostats.pl`: + +```AUTO +my sub parse_date ( $year, @line ) { + my $timestr = "$line[0] $line[1]"; + return Time::Piece->strptime( $timestr, '%b %d' ) + ->strftime("$year%m%d"); +} +``` + +--- + +### rcm + +* 💻 Languages: Ruby (99.8%), TOML (0.2%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 76 +* 📈 Lines of Code: 1373 +* 📄 Lines of Documentation: 48 +* 📅 Development Period: 2024-12-05 to 2025-02-28 +* 🔥 Recent Activity: 137.7 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🧪 Status: Experimental (no releases yet) + + +RCM (Ruby Configuration Management) is a lightweight, KISS (Keep It Simple, Stupid) configuration management system written in Ruby and designed for personal use. The project provides a domain-specific language (DSL) for declaratively managing system configuration, including files, directories, symlinks, and packages. It serves as an alternative to more complex configuration management tools like Ansible or Puppet, focusing on simplicity and ease of use for individual system administration tasks. + +The system is implemented with a modular architecture centered around a DSL class that provides keywords for different resource types (file, directory, symlink, touch, package). Each resource type inherits from a base Resource class and implements specific evaluation logic for creating, modifying, or removing system resources. Key features include automatic backup functionality (with SHA256 checksums), ERB template support, conditional execution, parent directory management, and support for file permissions and ownership. The system uses a declarative approach where users define desired states in configuration blocks, and RCM handles the imperative steps to achieve those states, making it particularly useful for personal dotfile management and system configuration automation. + +[View on Codeberg](https://codeberg.org/snonux/rcm) +[View on GitHub](https://github.com/snonux/rcm) + +Ruby from `lib/dsl.rb`: + +```AUTO +def to_s = @id +def evaluate! = @scheduled.each(&:evaluate!) + +def <<(obj) + raise DuplicateResource, "#{obj.id} already declared!" if @@objs.key?(obj.id) +``` + +--- + +### gemtexter + +* 💻 Languages: Shell (67.9%), CSS (28.9%), Config (2.0%), HTML (1.3%) +* 📚 Documentation: Text (76.8%), Markdown (23.2%) +* 📊 Commits: 461 +* 📈 Lines of Code: 2253 +* 📄 Lines of Documentation: 1170 +* 📅 Development Period: 2021-05-21 to 2025-06-11 +* 🔥 Recent Activity: 230.5 days (avg. age of last 42 commits) +* ⚖️ License: GPL-3.0 +* 🏷️ Latest Release: 3.0.0 (2024-10-01) + + +**Gemtexter** is a static site generator and blog engine that transforms content written in Gemini Gemtext format into multiple output formats. It's a comprehensive Bash-based tool designed to support the Gemini protocol (a simpler alternative to HTTP) while maintaining compatibility with traditional web technologies. The project converts a single source of Gemtext content into HTML (XHTML 1.0 Transitional), Markdown, and native Gemtext formats, enabling authors to write once and publish across multiple platforms including Gemini capsules, traditional websites, and GitHub/Codeberg pages. + +The implementation is built entirely in Bash (version 5.x+) using a modular library approach with separate source files for different functionality (atomfeed, gemfeed, HTML generation, Markdown conversion, templating, etc.). Key features include automatic blog post indexing, Atom feed generation, customizable HTML themes, source code highlighting, Bash-based templating system, and integrated Git workflow management. The architecture separates content directories by format (gemtext/, html/, md/) and includes comprehensive theming support, font embedding, and publishing workflows that can automatically sync content to multiple Git repositories for deployment on various platforms. + +[View on Codeberg](https://codeberg.org/snonux/gemtexter) +[View on GitHub](https://github.com/snonux/gemtexter) + +Shell from `lib/md.source.sh`: + +```AUTO +md::make_img () { + local link="$1"; shift + local descr="$1"; shift + + if [ -z "$descr" ]; then + echo "[![$link]($link)]($link) " + else + echo "[![$descr]($link \"$descr\")]($link) " + fi +``` + +--- + +### quicklogger + +* 💻 Languages: Go (97.6%), Shell (1.5%), TOML (0.9%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 32 +* 📈 Lines of Code: 917 +* 📄 Lines of Documentation: 33 +* 📅 Development Period: 2024-01-20 to 2025-07-06 +* 🔥 Recent Activity: 447.7 days (avg. age of last 42 commits) +* ⚖️ License: MIT +* 🏷️ Latest Release: v0.0.3 (2025-07-06) + + +[![quicklogger screenshot](showcase/quicklogger/image-1.png "quicklogger screenshot")](showcase/quicklogger/image-1.png) + +**QuickLogger** is a minimalist Go-based GUI application built with the Fyne framework that's designed for rapid text note capture, primarily targeting mobile Android devices. It provides a simple interface for quickly logging thoughts, ideas, or notes to timestamped Markdown files (`ql-YYMMDD-HHMMSS.md`) with customizable categorization through dropdown menus for tags, activities, and time periods. The app is optimized for mobile use with features like character count indicators, text length warnings, and a clear button for quick text clearing. + +[![quicklogger screenshot](showcase/quicklogger/image-2.png "quicklogger screenshot")](showcase/quicklogger/image-2.png) + +The project follows a clean, single-file architecture with all functionality contained in `main.go`, making it easy to understand and maintain. It includes both a main logging interface and a preferences window for customizing save directories and dropdown options. The build system supports cross-platform compilation with special focus on Android APK generation, and the saved files are designed to work well with file syncing tools like Syncthing, making it a practical tool for capturing notes on mobile devices that can be automatically synchronized across multiple devices. + +[View on Codeberg](https://codeberg.org/snonux/quicklogger) +[View on GitHub](https://github.com/snonux/quicklogger) + +Go from `main.go`: + +```AUTO +func createPreferenceWindow(a fyne.App) fyne.Window { + window := a.NewWindow("Preferences") + directoryPreference := widget.NewEntry() + directoryPreference.SetText(a.Preferences().StringWithFallback("Directory", defaultDirectory)) + + tagDropdownPreference := widget.NewEntry() + tagDropdownPreference.SetText(a.Preferences().StringWithFallback("Tags", strings.Join(defaultTagItems, ","))) + + whatDropdownPreference := widget.NewEntry() + whatDropdownPreference.SetText(a.Preferences().StringWithFallback("Whats", strings.Join(defaultWhatItems, ","))) + + window.SetContent(container.NewVBox( + container.NewVBox( + widget.NewLabel("Directory:"), + directoryPreference, + widget.NewLabel("Tags:"), + tagDropdownPreference, + widget.NewLabel("Whats:"), + whatDropdownPreference, + ), + container.NewHBox( + widget.NewButton("Save", func() { + a.Preferences().SetString("Directory", directoryPreference.Text) + a.Preferences().SetString("Tags", tagDropdownPreference.Text) + a.Preferences().SetString("Whats", whatDropdownPreference.Text) + window.Hide() + }), + widget.NewButton("Reset dropdowns", func() { + tagDropdownPreference.SetText(strings.Join(defaultTagItems, ",")) + whatDropdownPreference.SetText(strings.Join(defaultWhatItems, ",")) + }, + ), + ))) + window.Resize(windowSize) + + return window +} +``` + +--- + +### docker-gpodder-sync-server + +* 💻 Languages: Make (100.0%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 3 +* 📈 Lines of Code: 12 +* 📄 Lines of Documentation: 3 +* 📅 Development Period: 2024-03-24 to 2024-03-24 +* 🔥 Recent Activity: 471.5 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🧪 Status: Experimental (no releases yet) + + +This project is a **Docker containerization wrapper for a GPodder sync server**, specifically built around the micro-gpodder-server implementation from https://github.com/bohwaz/micro-gpodder-server. GPodder is a podcast client that allows users to synchronize their podcast subscriptions and episode states across multiple devices. The sync server enables this synchronization by providing a centralized service that podcast clients can connect to for managing subscriptions, episode progress, and playback history. + +The project is implemented as a simple Docker build system with a Makefile that provides convenient commands for building, running, and deploying the containerized service. The actual server code is included as a git submodule, while this wrapper provides infrastructure automation including data persistence through volume mounting (`./data` to `/var/www/server/data`), network configuration (port 8080 exposure), and AWS ECR deployment capabilities. This approach makes it easy to deploy a self-hosted GPodder sync server with minimal setup, useful for podcast enthusiasts who want to maintain their own synchronization service rather than relying on third-party services. + +[View on Codeberg](https://codeberg.org/snonux/docker-gpodder-sync-server) +[View on GitHub](https://github.com/snonux/docker-gpodder-sync-server) + +Make from `Makefile`: + +```AUTO +build: + docker build -t micro-gpodder-server ./micro-gpodder-server +run: build + if [ ! -d ./data ]; then mkdir ./data; fi + docker run \ + --name micro-gpodder-server \ + -v ./data:/var/www/server/data \ + --hostname gpodder.example.org \ + -p 8080:8080 micro-gpodder-server +aws: build +``` + +--- + +### terraform + +* 💻 Languages: HCL (96.6%), Make (1.9%), YAML (1.5%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 123 +* 📈 Lines of Code: 2850 +* 📄 Lines of Documentation: 52 +* 📅 Development Period: 2023-08-27 to 2025-04-05 +* 🔥 Recent Activity: 501.5 days (avg. age of last 42 commits) +* ⚖️ License: MIT +* 🧪 Status: Experimental (no releases yet) + + +This is a comprehensive personal cloud infrastructure project built with Terraform that deploys a multi-tier AWS architecture for hosting self-hosted services. The infrastructure is organized into modular components: `org-buetow-base` provides the foundation (VPC, subnets, EFS storage, ECR), `org-buetow-bastion` creates a bastion host for secure access, `org-buetow-elb` sets up application load balancing, and `org-buetow-ecs` runs containerized services on AWS Fargate. The project also includes an EKS cluster option with EFS CSI driver integration for Kubernetes workloads. + +The system is designed to host multiple personal services including Anki sync server, Audiobookshelf, Vaultwarden, Syncthing, Radicale (CalDAV/CardDAV), and others, all with persistent storage via EFS and secure TLS termination. The architecture follows AWS best practices with remote state management in S3, proper networking isolation, and automated backups, making it useful for individuals wanting to run their own private cloud services with enterprise-grade reliability and security. + +[View on Codeberg](https://codeberg.org/snonux/terraform) +[View on GitHub](https://github.com/snonux/terraform) + +HCL from `org-buetow-ecs/variables.tf`: + +```AUTO + type = bool + default = false +} + +variable "deploy_audiobookshelf" { + description = "Deploy Audio Bool Shelf Server?" + type = bool + default = true +} +``` + +--- + +### gogios + +* 💻 Languages: Go (94.4%), YAML (3.4%), JSON (2.2%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 77 +* 📈 Lines of Code: 1096 +* 📄 Lines of Documentation: 287 +* 📅 Development Period: 2023-04-17 to 2025-06-12 +* 🔥 Recent Activity: 514.4 days (avg. age of last 42 commits) +* ⚖️ License: Custom License +* 🏷️ Latest Release: v1.1.0 (2024-05-03) +* 🤖 AI-Assisted: This project was partially created with the help of generative AI + + +[![gogios screenshot](showcase/gogios/image-1.png "gogios screenshot")](showcase/gogios/image-1.png) + +Gogios is a lightweight, minimalistic monitoring tool written in Go designed for small-scale server monitoring. It executes standard Nagios-compatible check plugins and sends email notifications only when service states change, making it ideal for personal infrastructure or small environments with limited resources. The tool emphasizes simplicity over complexity, avoiding the bloat of enterprise monitoring solutions like Nagios, Icinga, or Prometheus by eliminating features like web UIs, databases, contact groups, and clustering. + +The implementation follows a clean architecture with concurrent check execution, dependency management, and persistent state tracking. Key features include state-based notifications (only alerts on status changes), configurable retry logic, federation support for distributed monitoring, and stale detection for checks that haven't run recently. The tool is configured via JSON and requires only a local mail transfer agent for notifications. It's designed to run via cron jobs and supports high-availability setups through simple dual-server configurations, making it perfect for users who want effective monitoring without operational overhead. + +[View on Codeberg](https://codeberg.org/snonux/gogios) +[View on GitHub](https://github.com/snonux/gogios) + +Go from `internal/run.go`: + +```AUTO +func persistReport(subject, body string, conf config) error { + reportFile := fmt.Sprintf("%s/report.txt", conf.StateDir) + tmpFile := fmt.Sprintf("%s.tmp", reportFile) + + f, err := os.Create(tmpFile) + if err != nil { + return err + } + defer f.Close() + + if _, err = f.WriteString(fmt.Sprintf("%s\n\n", subject)); err != nil { + return err + } + if _, err = f.WriteString(body); err != nil { + return err + } + return os.Rename(tmpFile, reportFile) +} +``` + +--- + +### docker-radicale-server + +* 💻 Languages: Docker (53.1%), Make (46.9%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 4 +* 📈 Lines of Code: 32 +* 📄 Lines of Documentation: 3 +* 📅 Development Period: 2023-12-31 to 2023-12-31 +* 🔥 Recent Activity: 555.1 days (avg. age of last 42 commits) +* ⚖️ License: No license found +* 🧪 Status: Experimental (no releases yet) + + +This project is a **Docker containerization setup for Radicale**, a CalDAV and CardDAV server written in Python. Radicale is a lightweight, standards-compliant calendar and contacts server that allows users to synchronize their calendars and address books across multiple devices and applications. The project provides a complete Docker image and deployment configuration that makes it easy to run a personal or small-team calendar/contacts server. + +The implementation uses Alpine Linux as the base image for a minimal footprint, installs Python 3 and Radicale via pip, and configures the server with HTTP basic authentication using htpasswd. The setup includes persistent storage for collections (calendars/contacts) and authentication data through Docker volumes, exposes the service on port 8080, and includes a Makefile for easy building and deployment. The project also supports pushing to AWS ECR for cloud deployment, making it suitable for both local development and production use cases where you need a self-hosted alternative to cloud-based calendar services. + +[View on Codeberg](https://codeberg.org/snonux/docker-radicale-server) +[View on GitHub](https://github.com/snonux/docker-radicale-server) + +Make from `Makefile`: + +```AUTO +build: + docker build -t radicale . +run: build + if [ ! -d collections ]; then mkdir collections; fi + if [ ! -d auth ]; then mkdir auth; fi + cp -v htpasswd-test auth/htpasswd + sh -c 'docker rm radicale; exit 0' + docker run \ + -v collections:/collections \ + -v auth:/auth \ +``` + +--- + +### docker-anki-sync-server + +* 💻 Languages: Docker (62.1%), Make (37.9%) +* 📚 Documentation: Markdown (100.0%) +* 📊 Commits: 3 +* 📈 Lines of Code: 29 +* 📄 Lines of Documentation: 3 +* 📅 Development Period: 2023-08-13 to 2024-01-01 +* 🔥 Recent Activity: 648.3 days (avg. age of last 42 commits) +* ⚖️ License: MIT +* 🧪 Status: Experimental (no releases yet) + + +This project is a Docker containerization of the Anki sync server, designed to provide a self-hosted synchronization service for Anki flashcard applications. Anki is a popular spaced repetition learning tool, and this project allows users to run their own sync server instead of relying on AnkiWeb's hosted service, giving them full control over their data privacy and synchronization infrastructure. + +The implementation is built using a Rocky Linux base image with Python 3.9, and it integrates the community-maintained `anki-sync-server` project. The Dockerfile:dockerfile:1-19 sets up the environment by installing dependencies, configuring data paths for collections and authentication databases to persist in `/data`, and running the service under a dedicated user for security. The Makefile:makefile:1-12 provides build automation that clones the upstream anki-sync-server repository and includes AWS ECR deployment capabilities for cloud hosting. This containerized approach makes it easy to deploy and manage an Anki sync server across different environments while maintaining data persistence through volume mounts. + +[View on Codeberg](https://codeberg.org/snonux/docker-anki-sync-server) +[View on GitHub](https://github.com/snonux/docker-anki-sync-server) + +Make from `Makefile`: + +```AUTO +all: + if [ ! -d anki-sync-server ]; then \ + git clone https://github.com/ankicommunity/anki-sync-server; \ + else \ + cd anki-sync-server && git pull && cd ..; \ + fi + docker build -t anki-sync-server:latest . +aws: + docker buil