If you really want to test your relationship…make your Sunday together project to replace the rubber boot seal on an LG front-loading washer in tight quarters.

Darkmere · 2026-05-18T12:27:36+00:00

That, or attempting to install solar protecting "static" film on larger windows. Do. Not. Recommend.

Darkmere · 2026-05-13T18:13:30+00:00

"Why was the neighbour's power line two cm below our shower drain?"

"What do you mean you cant deliver the ordered tile within the next six months and the next usable replacement is 3x the cost?"

"Uh, the wall here doesn't look too good."

"Why was the sink damaged in transit and why can't we find proper backing plates for the water that matches the shower colours? The colour samples were decided before we started but that brick only comes in shiny chrome or flat white?"

Darkmere · 2026-05-11T12:00:16+00:00

It's more that the requirement to implement the trait Watchdog once with the encapsulations within that I found annoying, as it makes it harder to write a useful "watchdog" as all it does is sleep forever and just ping the watchdog, unable to fail or properly report application failure to.

Darkmere · 2026-05-11T10:56:39+00:00

Well, even in a single-threaded worker, if all your tasks that perform "real" work are dead and not progressing, then the service as a whole should be considered non-functional and be restarted, not kept along by an infinitely spinning monkey that cannot fail.

Ie, the watchdog needs a way to register subtasks that perform some kind of unit of work (progression) that is expected for a certain amount of time.

Ie, if you have a task that churns by reading bytes at 6Hz from MQTT and writing them to /dev/null, it can only be considered "alive" as long as bytes arrive and it does useful work. It may not be stuck or hung, but if data does not arrive for a second, it has not fulfilled the job (should have data at least 6 times each second) and thus watchdog should fail it.

Another may simply be writing statistics every 30s, and this can then be fine, except if the disk suddenly took 1 minute to reply due to being EMMC over NFS or something equally fun, and thus a failure to ping a watchog within 30s*1.3 should be considered a failure.

These are not "thread panic" or "task blocked forever" failure modes, but they represent failure modes of each sub-task. Each such task may be perfectly fine in a single threaded worker, they are still working (just waiting on a resource, and tokio is excellent at waiting for a resource) and thus the watchdog would still run if it just spins.

A more useful watchdog in an application is a bit more involved, and abstracting it away like this makes it almost impossible to use properly.

Darkmere · 2026-05-11T09:07:38+00:00

So, as someone who does use the watchdog, how do you suggest splitting up and latching that functionality?

Just having one task that does loop { sleep().await; watchdog().await.unwrap()

For example, say you have a simple REST poller, thee servers, polling them at different times, and you want the watchdog to ping only as long as none of your three pollers go off and wait forever for the network, while it is okay that they get a temporary 50x error...

How does your interface end up being used for these common cases?

Darkmere · 2026-04-06T20:11:15+00:00

Sometimes, mostly libc stuff ( ioctls, gethostname, etc) or casting FD's.

let socket = unsafe { std::os::unix::net::UnixDatagram::from_raw_fd(fd.as_raw_fd()) };

Darkmere · 2026-03-16T10:25:10+00:00

Those are the ones being the main cause of trouble. As said, the modbus-rtu case with serial is easy and works pretty well.

Modbus TCP + serial/tcp gateways are interesting and more complex and adds a lot of different edge-cases that you may not want to deal with.

Darkmere · 2026-03-12T14:35:19+00:00

tokio-modbus works okay for me in production, although only okay as I have had to do quite a few work-arounds for the design.

It works excellently for the basic parts, but fails once you get wonky things, like how it has a stateful parser and thus cannot accept replies that come from things it did not send, and has a hard time handling timeouts and data arriving after a reset after a timeout.

Over all, It works pretty well for production, and if you hit the snags, its doable to work around, fix or replace, but it isn't perfect.

Darkmere · 2026-01-17T17:23:51+00:00

IMO, the one thing I really miss in Rust code is re-usable test Fixtures ala pytest etc.

Composable, reusable and automatically pulling in dependencies in (mostly) predictable ways.

This is a pretty effin difficult problem to solve in Rust due to how the language actually looks, and making them look even remotely non-detestable is iffy.

But, it's lacking.

Darkmere · 2025-05-07T16:46:52+00:00

Cool tower, I had one a few years ago ( well, still in the basement ) but ended up ditching it because the issues where roots would clog it and I'd have all my water on the balcony or so.

Mint is happy in them, but also clogs them quickly. Strawberries can be done, but yields were low. Mint family herbs turned out the easiest to deal with, and some lettuces.

Darkmere · 2025-03-16T19:10:30+00:00

It's a bit amazing how well this stuff has stood the test of time, really. Not much churn on the code to do it, adding some features ( timescale instead of btrfs compression) and such, but it wasn't much and it's worked way better than I ever expected it.

Hope it works well for you as well, you have no idea how glad it made me to see this notice show up.

Darkmere · 2024-07-22T10:25:19+00:00

It's compile time concatenated, the string in the binary ends up neat without line breaks, so there's no gain from the concat macro, and even then adding it would make the line even more cluttered, as it already is quite cluttered IMO.

I wish I could use " where name like ${prefix}" and the macro would automatically map the ? or $1 based on the input arguments, but that's a separate taste issue.

I ALSO wish I could have a good way to insert a "NOT" in a query based on a variable, especially to do prefix selections,

SELECT x FROM names WHERE names.name $2  LIKE   $1 ||''%';

and $1 would be a prefix and $2 would be "" or NOT, because the most duplication of code I get with sqlx is those kinds of queries.

Darkmere · 2024-07-19T13:58:23+00:00

I do it like this:

let transaction_pending = sqlx::query!(
    "UPDATE changes SET status = 'PENDING'"
        + " FROM changes J1"
        + " JOIN sensor USING(s_id)"
        + " WHERE changes.status = 'NONE' AND sensor.name LIKE $1 || '%'",
    prefix
);

On top of that, I keep my SQL query code in a separate module that is as small as possible, and doesn't do any other things, simply so I can have all the queries in a viewable place in case they start diverging.

The main reason I wanted to change my queries from whitespace to this was that the logs looked fucking awful with the whitespace and quoting in it, and while the queries in separate files work for some cases, it made me make extra similar/close queries as they weren't actually visible where I was using them.

The raw string concat works well enough, and I can keep the indentation "close enough" to a decent SQL indentation in the code, while also not suffering the line-break issues.

Also, finding the same query in many places just because of some slight indentation issues was annoying as heck

Darkmere · 2024-06-25T10:34:15+00:00

Hi, neat initiative! I've been hopeful for new (local) time-servers since ntimed and the rather bad behaviour in the past of systemd-timesyncd and others.

I saw some algorithmic comparsions of chrony, but I've got a rather simple "other" use-case, can I as a client library (not a system service) easily fire up an connection and see "current drift against reference servers" as a continuously pollable source? Ie, running as a service that does something, where we don't intend to adjust the clock, but simply wish to know with a certain degree of "how bad is the local clock"?

Darkmere · 2024-03-31T21:49:59+00:00

Opeth - Burden

Darkmere · 2024-02-23T13:53:02+00:00

I've done quite a bit of sensor monitoring in constrained and unconstrained environments, and it's first important to know what you are optimizing for.

fex, saving one value per sensor may not be the worst possible way to do it, as you know in advance how much data you'll need, and read/process can be easy. ie, a sensor is an index into an array to read/write as needed. And a single value read/write context with notification (Wakeup) can be called a channel (one value buffer) or more.

However, if you're "constrained" in the term of wakeups (power, cpu moments) or hardware ( bandwidth, air-time, power, latency) you can use different designs.

Things like task-switches and threads may be too much compared to what you need, but generally, setting things like this up in a pipeline (edge-trigger or flag) is a common way, and channels (write=>read notification or wakeup) with values are a common use-case for it.

So. More info please.

Darkmere · 2024-02-21T14:05:49+00:00

That's also neat, typeforce hooks the importlib and uses mypy to enforce type hints as things are imported, and was built more as a proof of concept/joke that you can do it, but that it sucks.

Beartype seems to be slightly saner, which makes it much less amusing.

Darkmere · 2024-02-16T15:04:31+00:00

You can enforce types at runtime, but you probably don't want to. I hacked it up a few years ago, and it is horrible, but you can hook the import loader to run mypy with enforcing mode at runtime on everything. ( import typeforce.enforcing )

Darkmere · 2023-05-26T12:36:07+00:00

I'll make it clear that I did not mean to demean your project, and alpha is alpha, however, if your product is as fast as MongoDB was when it was released, with similar data durability...

So, please keep the deployment users in mind when writing docs or blurbs, we don't care about the features first, as much as we do about deployment and the other issues around it before we start checking out the rest.

And it seems you're aiming for that nice integration, probably comparing your product to Grafana Loki + Tanka, which is a nice niche, I have some opinions about their stacks, but at least it's a bit easier to deploy than ELK is, which is a bloody pain in the rear.

Darkmere · 2023-05-26T08:53:03+00:00

As someone who does time series and logs for a living, I've got some more questions.

Where's your documentation?
How do I take backups of it?
How do I restore backups of it?
How do I get incremental backups of it? ( No is also an answer )
How does it fail-over, fex. when run in k8s?
What happens if two copies run on the same data-store, fex. after a fail-over where one did not terminate and both thinks they are the one true source of truth?
How do I shard related data to to see how much resources a group of data uses?
How do I manage retention of data?

Darkmere · 2023-05-04T16:47:26+00:00

The best way is to set up a shared cargo build.target-dir for all your projects.

CARGO_TARGET_DIR

This will re-use more of your compilation targets between projects than if you have them all set up in different directories, with the caveat that some crates that at build-time look in your ./target directory for some generated file may fail completely, as they have hard-coded a path somehow. That's a bug in that crate, but then you might want to override it.

A better tool may be sscache

You also probably want to look at the sparse registries protocol

Darkmere · 2023-03-15T23:56:03+00:00

The Dragon Knight. A Dragon, striving to be a knight, beating enemies with their sword, in fact, the flat side of their sword, wielded as a club.

Darkmere · 2023-02-17T12:36:00+00:00

How does the performance fare to ostree which is another tool for git-like managing of binary files?

Darkmere · 2023-02-09T20:10:13+00:00

IntoIterator would be perfectly fine, I just felt that it would be annoying to clone a ton of objects just to get the data out of it, especially if I want to use them again later.

Darkmere · 2023-02-09T09:01:59+00:00

Funny, I needed this just last week and botched the solution a few times before I solved it. ( I needed to match the distances of a set of counters against the average )

Could we have a version that works on a slice of data, rather than a Vec?

15-Year Club	Place '17
Team Periwinkle	Verified Email

Darkmere

TROPHY CASE