Engineers often complain that visibility should be their manager’s job. In other words, they think engineers should be able to focus on the code, while their manager figures out who’s doing well and rewards them.

This attitude is an extension of the “school fantasy”: the idea that your workplace should operate by the same rules as your school or university. After all, you didn’t have to worry about “visibility” during your education. You simply did the assignments and tests you were given, and if you did well you were rewarded with a good grade.

Many big tech companies encourage this attitude, because it helps them recruit smart graduates. They fashion their workplaces to look and feel like a university, even calling the physical space “campuses”. But it’s still work, not school. If you treat it like school, you are going to have a bad time.

i got an idea to build a semi-hypervisor, or rather, a supervisor, for a cortex-M3 system (i’ve chosen blue pill because it’s cheap and because i have tons of them).

iceoryx2 provides zero-copy inter-process communication mechanisms based on shared memory and data structures that are modified concurrently by multiple processes.

One of the key operations in these algorithms is a memory copy using core::ptr::copy. However, this results in undefined behavior if one process reads the data while another process writes to it concurrently. Even if our lock-free algorithm reliably detects such a race, iceoryx2 cannot depend on undefined behavior in a safety-critical system.

This blog post introduces our solution: a byte-wise atomic wrapper that enables well-defined concurrent copy operations. It also shows how it can be used to implement a simple sequence lock.

Note: I am not the original author of the blog post. Since the author does not have a programming.dev account, I am posting it on her behalf.

Deployed a backup script on a new server, tested it manually — worked fine. Set up crontab, came back next morning, no backup. Turns out /usr/local/bin wasn't in cron's PATH so pg_dump just silently didn't exist.

Switched to absolute path and it worked immediately. Fifteen minutes of debugging for a one-character fix. I keep making this mistake every time I set up a new box. At this point I should just have a checklist taped to my monitor.

Hugging Face crawls as many GitHub repositories as it can with the help of the Software Heritage Archive so as to create their Stack v2 LLM for code. And of course without consent of rights holders.

Opt-out is possible.

I idemkit after cleaning up duplicate charges one too many times.

The version everyone writes checks whether a key has been seen and replays the stored response. Two requests a millisecond apart both find nothing and both charge the card. And if the worker dies between charging and recording it, the retry charges again. Neither reproduces locally.

idemkit does it properly: an atomic claim instead of check-then-act, a lease that expires on the storage server’s clock, and a fencing token so a stalled worker can’t overwrite a good result.

from idemkit import idempotent, RedisBackend, MethodConfig 

@idempotent(
    backend=RedisBackend.from_url("redis://localhost:6379"), 
    config=MethodConfig(key_fields=["order_id"]), 
) 
async def charge(*, order_id, amount): 
    return await payments.charge(order_id, amount)

One core, three ways to use it: middleware for FastAPI/Flask/Django, a queue consumer wrapper or @idempotent on any function. Backends are Redis, Postgres, Mongo, DynamoDB, or in-memory for tests.

pip install idemkit, Apache-2.0: https://github.com/idemkit/idemkit

If you find it useful, I'd appreciate a star. It's new, so visibility helps a lot right now.

Nobody argues with SRP in principle. Every developer I've worked with agrees a function should do one thing. The argument is always at the example, whether a given function is one thing or six, and that is the part the rule itself doesn't settle.

Two things have done most of the work for me.

The name. If you need an "and" to describe what the function does, it's two jobs. Saying it out loud forces the description to be honest, and once you have said "it validates the order and then submits it" the extraction is obvious without anyone arguing about line counts.

The actor question, from Clean Architecture: who pays when this changes. Two sets of people filing bugs against the same function is a boundary problem however short that function is. Parnas got to the same place in 1972 by listing the design decisions likely to change and giving each one a module that hides it.

Length and complexity limits catch the same smell and I do run them, but they are proxies. A long function with a single reason to change is fine, and a short one serving two teams isn't.

This has mattered more since agents started writing the first draft. A developer reading a fuzzy boundary works the intent out from the surrounding code. An agent takes the boundary as given and builds on it.

I write these up at https://prickles.org/tenet/single-responsibility-principle/F1 if the longer version is useful.

StatusGator last checked the status of Codeberg on July 31, 2026 at 7:57 PM CEST and the service was operational. There have been 83 user-submitted reports of outages in the past 24 hours, but the outage is now resolved.

I've applied to between 550-600 jobs since December and hardly heard anything back. The past two weeks recruiters started reaching out to me and at this point I'm at least having early round discussions with 5 companies. They're mostly smaller and somewhere in the health care space, but I went from virtually 0 to having something. Obviously it's early stages so you can't count on anything, but it looks like things may be picking up again.

I built a service whose primary client is a CLI program. I was thinking about building that client for Windows as well (not just WSL). My target users are generally technically-proficient so I'd rather not build a whole GUI app if it's unnecessary. But I honestly have no idea how often Windows users use CLI tools beyond some Windows admin stuff.

So if Windows is your daily driver, how often do you leverage the shell and how unusual would it be to use CLI tools in your workflows?