What do y'all use to assess GitHub action usage? I made one but Ive got now info or clue on usage, installs, etc. Whats your workflow and how do you monitor them?
Hey everyone. I'm an outsider here, but to embrace the spirit of this sub: I don't trust you, and I assume you don't trust me.
I don't trust my dependencies, I don't trust hallucination-prone LLMs, and I don't trust brittle ASTs (Abstract Syntax Trees) that break if the code doesn't perfectly compile.
The problem with modern static analysis is that we blindly trust what a repository claims to be. We take manifest files (like package.json or pom.xml) at face value. We trust that a file ending in .md, .csv, or .json is actually inert text.
That isn't Zero Trust. Taking a manifest at its word leaves your pipeline completely vulnerable to dependency confusion, typosquatting, or spoofed packages.
If we apply true Zero Trust to a codebase, file identities must be confirmed with different levels of evidence. If a file claims to be a plaintext document, we shouldn't just trust the extension. We need to physically verify its identity—looking at execution shebangs, magic bytes, or the presence of specific executable keywords—to prove it's not a disguised shell script or payload.
Manifests should be treated as mere "claims of intent." Their claims must be physically verified against the actual binaries downloaded to the disk before they are allowed to execute.
I wanted something fast enough to scan every PR in full, and to be able to scan every single codebase I download before I ever run it. Because ASTs and LLMs couldn't do this at scale, I built my own open-source zero-trust code scanner. It's on one of the code versioning sites, I'll trust you to figure out the rest.
Currently, Karnataka India is the world leader on the site.
I want to share Ninelives. It is a robotics framework that assumes every signal might be compromised and addresses that head-on.
It is an industrial-grade, fault-tolerant SCADA middleware built for individual machine builders and hobbyist hardware engineers. Ninelives allows you to take a spool of unshielded wire, a handful of hobbyist sensors, and a few microcontrollers, and quickly engineer a highly deterministic, resilient distributed robotics system.
My current setup uses a Raspberry Pi 5 as the central "Brain". It controls a distributed RS-485 network of RP2350 "Limbs" to run my high-speed Lego sorter, "Meow Turtle".
Features:
Limb RP2350 Dual-Core Architecture (Clerk & Machinist)
Custom MTIP Transport Layer
Enterprise Mass OTA Flashing
Sensor Error Handling (Humble Drivers)
Actuator State Validation
Watchdogs & The "Ghost Exit" Bootloader
boot.py to abort the main app.heres the code:
Hey all,
I'm a biology instructor at a Community college. I built this a math facts mastery tool that tracks not just mastery but determination. I gamified the learning and focused on instantaneous feedback, visual positive feedback and fast testing abilities. I built it for my daughters. What do you think? Feel free to share or use.
I also built in a silly leaderboard for the competitive students.
gen ai disclosure - I made with gemini, me and Gemini going back and forth, i read and test the code. built off a django template I run. pytesting, ruff, black, codeql, dependabot, flake used in ci/cd pipeline for code quality.
I’m engineering a large-scale AI-powered Lego sorting machine utilizing computer vision and pneumatic systems. The physical architecture relies on a central Raspberry Pi 5 "Brain" orchestrating a fleet of RP2040 Picos (acting as hardware limbs) over an asynchronous RS-485 bus.
Initially, I evaluated standard industrial buses, but after running network calculations on baud rates, data transfer speeds, and our specific latency requirements for pneumatic actuation, Modbus and CAN didn't fit the use case. We needed a system capable of handling highly flexible, variable-length payloads to pass complex operational strings between the CV engine and the hardware, without getting bogged down by fragmentation or rigid register mapping. To solve this, I wrote a custom Python transport layer designed specifically for this workflow
Here are the unique architectural features of the MTIP system:
Flexible Data Delivery: Instead of tight 8-byte/64-byte binary packing, the protocol natively supports variable-length ASCII string payloads. This allows for massive flexibility in how data is delivered from the CV engine directly to the microcontrollers.
Greedy Ingestion & Safety Preemption:
Standard sequential polling wasn't fast enough for critical stops. The read loop dynamically drains the entire 4KB hardware buffer in one pass, parses it, and explicitly sorts the incoming packets. This allows MSG_TYPE_ALARM or stop commands to jump the processing queue over standard telemetry.
Piggybacked W-Protocol:
To maximize the 115200 baud throughput, state-wipe commands and sequence ACKs are bundled and piggybacked onto standard telemetry packets, preventing unnecessary bus traffic. Noise Harvesting & Bayesian LQI: Instead of just dropping corrupted packets, the transport layer captures CRC failures and sequence skips, forwarding them as diagnostic metrics to a digital twin to maintain a Bayesian Link Quality Indicator.
protocol https://github.com/squid-protocol/meow-turtle/blob/main/core0%20-%20Commander/lib/meowprotocol.py
parser https://github.com/squid-protocol/meow-turtle/blob/main/core0%20-%20Commander/lib/protocol_parser.py
vid in action https://youtube.com/shorts/_swgFbqY9CQ?si=rK4KiytzCPKZLkA1
https://github.com/squid-protocol/math_facts
Hey r/webdev, I originally built this to give my kids a more video-game-like feedback loop for learning multiplication, but the architecture turned out to be a really fun frontend challenge.
Traditional online flashcards only measure right or wrong. They don't measure the difference between instant recall and slowly counting on your fingers. I wanted to track exact processing speed and the "determination" it takes to push through mistakes, so I built FastMathFacts.io. Here are the technical highlights I wanted to share:
Thick Client Vue SPA for Millisecond Accuracy: To get absolute precision on the timing, relying on server round-trips for the core gameplay loop was out of the question. The entire practice engine runs locally in the browser as a thick client. This guarantees deterministic, millisecond-accurate tracking of how fast a user inputs an answer, completely immune to network latency. The UI state and timer logic handle the rapid-fire inputs instantly.
Leaflet Analytics & Global Leaderboard:
To make the stats actually interesting to look at, I integrated Leaflet to map out the leaderboard. Instead of a boring table, it visually plots where users are grinding through the math facts and hitting mastery thresholds across the globe. The overarching goal was high performance and instant, visual feedback without any server-side sluggishness breaking the user's flow state.
So my app is basically just a calculator and a checker but changing how I did it (client side for speed, leaflet map for scoreboard) made it feel like something greater than it's parts.
Anything else you'd do to make it unique?
Hey all,
I'm a biology instructor at a Community college. I built this a math facts mastery tool that tracks not just mastery but determination. I gamified the learning and focused on instantaneous feedback, visual positive feedback and fast testing abilities. I built it for my daughters. What do you think? Feel free to share or use.
I also built in a silly leaderboard for the competitive students.
gen ai disclosure - I made with gemini, me and Gemini going back and forth, i read and test the code. built off a django template I run. pytesting, ruff, black, codeql, dependabot, flake used in ci/cd pipeline for code quality.
FastMathFacts is essentially a high-speed calculator with a checker attached. Nothing fancy, no distractions—just raw, fast-paced practice.
The Engine:
The Competition:
Test your speed and build real fluency here: https://www.fastmathfacts.io/
gen ai disclosure - made with gemini, me and Gemini going back and forth, i read and test the code. built off a django template I run. pytesting, ruff, black, codeql, dependabot, flake used in ci/cd pipeline for code quality - https://github.com/squid-protocol/math_facts/tree/main
I found a tiny hole in the world of existing products. Smaller than an exhaust port on the death star. It's a multiplication game. To help ppl learn multiplication. It's basically a calculator with a checker. BUT. I tried to gamify and make it as rewarding as possible to continue with supportive teaching techniques.
I built a competitive leader board that ranks countries against each other
So while the plot is simple, I tried to make it sticky so people actually want to improve their multiplication skills. My long term goal is to connect with companies that do niche banner ads and only run legit educational ads. https://www.fastmathfacts.io/
So I guess the real idea was to find simple things that could use a modern touch. I don't expect this to be huge and there might be a steady market for this. And it might do some good in the world.
How'd I do on taking a boring idea and making into something that motivates ppl to learn?
No Fluff. Just Fast Math.
If you are tired of bloated educational apps, I built something entirely different. FastMathFacts is essentially a high-speed calculator with a checker attached. Nothing fancy, no distractions—just raw, fast-paced practice.
The Engine:
The Competition:
Test your speed and build real fluency here: https://www.fastmathfacts.io/
gen ai disclosure - made with gemini, me and gemin going back and forth, i read and test the code. built off a django template I run. pytesting, ruff, black, codeql, dependabot, flake used in ci/cd pipeline for code quality - https://github.com/squid-protocol/math_facts/tree/main
Hey all,
I'm new the world of interpreting pypi numbers and peaks and trends. What would you say about this? https://pepy.tech/projects/gitgalaxy?timeRange=threeMonths&category=version&includeCIDownloads=true&granularity=daily&viewType=line&versions=Total%2C2.*%2C1.* I've got 11k downloads in 2 months but 36 GitHub stars. Is this a normal ratio? Are most of these bots? It seems like GitHub stars are rare but downloads have some basal amount of noise values? Or is this a strong signal that some ppl have found value in my project? why are the peaks so peaky?
And could you use more?
edit: I got a lot of negativity from some folks and I'm disappointed. I thought this was a community for 0-200 acre farms of different types, according to the about. but some folks have don't seem to be accepting of a 1 acre volunteer system where i live. mostly manual labor. family run. farmers market and 35 csa members and they can choose If they opt to a work share instead. which we have 20 working a 50 pr 75 hour season commitment. we don't force it. they seem happy. my members don't call me POS. ppl say I'm an upstanding member of the community. I don't enjoy being called a POS. any better communities to hang out in?
what's with the anger? is there some group of villianous farmers that like trick ppl into forced hard labor? Ppl be acting like I'm going holding ppl hostage at gun point. Lol.
but you can try it yourself with pip install gitgalaxy and my visualization website - gitgalaxy.io
Like a csa but you work instead of paying?
hey all, i'm a phd in pharmacology on a long and strange journey - anywho -
Most giant legacy modernization efforts fail because they feed raw COBOL directly into an LLM, which almost always results in hallucinated architectures and broken mappings.
Instead of relying on AI for the foundation, I built a deterministic, AST-free heuristic engine (blAST) that handles the boilerplate scaffolding first. It focuses strictly on translating the physical memory constraints of legacy mainframes into valid Java 17 syntax. And then we make lists of things that the algorithm cant handle for ppl or ai agents.
How the memory and architecture mapping works:
Translating legacy PIC clauses directly to BigDecimal types
Resolving OCCURS arrays into standard Java List<> collections
Mapping REDEFINES memory overlays as u/ Transient JPA aliases
Safely unpacking COMP-3 (Packed Decimal) data boundaries
Auto-wiring the u/ Service layer via constructor injection
Scaffolding ready-to-use u/ RestController endpoints
The CI/CD battle-test metrics:
Stress-tested across a randomized corpus of 27 distinct legacy repositories
Processing complex IBM CICS banking applications
Generating complete, production-ready Maven pom.xml configurations
Auto-generating mock services to shield missing external dependencies
Achieving a 100% out-of-the-box mvn clean compile success rate across all 27 targets
By doing the deterministic grunt work first, the engine isolates the actual business logic into strict JSON tickets. If you do want to use an LLM, you are just feeding it a bounded logic problem instead of asking it to hallucinate an entire Spring Context.
git - https://github.com/squid-protocol/gitgalaxy/tree/main/gitgalaxy/tools/cobol_to_java
How would you tell others how you spent your time? Did you land rush it for monetization? Build tools, develop passions and hobbies, become more skillful than you imagined? Did you make something lasting ?
What been your experience? I've gotten okay engagement with YouTube shorts and I'm wondering if I should give LinkedIn a try, how it's different, etc.