e-dant

Let the language die, hope it goes quicker than cobol.

These were three pants from Lululemon, figured they’d be good.

None of them lasted more than 6 months.

Admittedly, I bike and walk a lot, so probably I put more strain on them than I should have.

But, come on, that’s why I got them, and surely if I can bike 20 miles in $30 pants from target, those fancy lululemon pants should also have worked.

Few years back, I thought it was wise to invest in some semi-pricey clothes which were intended to suite me for a while. The only formal stuff I had at the time was my Dad’s, or something I thrifted, which didn’t quite fit.

Some pants, shirts, which I could put a jacket over for something more formal. Some shorts and shirts for the gym.

Every single one of those pants ripped, to my surprise, because some of them were $150-$250. Some ripped in the belt loops, others between the legs. The dress shirt is barely holding up, there are little plumes of ripped material on the side.

Each time they ripped, I replaced them with something I found for $15-35 at Target. Not a single rip.

I still keep the dress shirt, because it’s the only one I have, and I’m not at all sure what to replace it with.

I dislike the shirts that Target sells because the frame they use is of a long, skinny man, with small arms, and an extremely wide neck. Not sure how the fuck that happened. But the material is perfectly fine.

If anyone knows where I can find a nice shirt (both collared and others for the gym), that’d be great. I’m set on target pants, though. They are indestructible.

Part of why monads are not interesting to talk about is that they’re generic enough that most explanations are incomplete, and sufficient explanations are boring and unhelpful.

But the biggest reason is that they’re sort of intuitive, plenty examples exist. And then at some point someone tells you that those things are monads, but it’s in the kind of way that social psychologists make up some fancy word for crap we all know about in our gut.

Nobody gives a shit that a list is a monad, people give a shit that it’s a list. Anyone who’s written lisp or node or any nontrivial C program or anything with coroutines or anything with concurrency can and will tell you that, yeah, duh, control flow can be represented by a data structure. A couple more fancy “monad laws” and you have something that looks like other monads, and lists and if expressions and IO meld together. Ok, how unhelpful.

Linux has pledge? Huh?

`pledged = (p->p_p->ps_flags & PS_PLEDGE);`

Feels like clojure from afar

I want to thank everyone here who pointed out deficiencies in this little library.

Good catches :)

Nevermind — there are ways for deleting colliding items to cause other colliding items to be “forgotten”, and one solution would be to implement slot cycling on deletion

Good catch! Yes, that looks like a bug :)

There’s no slot cycling logic. When a k,v pair at some index is deleted, and a different k,v pair has a matching hash, there’s a (small?) penalty in the hm_get logic that will eventually the right k,v pair.

I need a bit more clarification on your first question. There should be no mutation of the underlying map when it grows — we’re just allocating more room for entries and adjusting the old map’s item “ownership” — moving pointers->items around.

I like the exercise of trying to find the simplest reasonable solution to some problem.

Many of my toy and hobby projects are exactly that. Some make allowances for the sake of performance and generality.

The hash map, though, is up there with sorting algorithms in the breadth of wild implementations. Salmagundi is unlikely to be the fastest, or the smartest. But it’s cute and portable.

Huh — I must have written djb1 in error

This was originally meant to solve the problem of zombie processes in Docker containers (hence the name and issue nr.; moby/9098).

I’ve found this more succinct in other contexts than backgrounding tasks, writing pid files, and maintaining them through the process’s lifetime.

Also less prone to error.

logrotate (which you really ought to use if you can) happens to use rename() under the hood to move the primary logfile into rotation, which confuses programs already writing to it (they will now be writing to the rotated file, which is weird). frots was primarily made to solve that problem.

I hate init py files the same way I hate Java’s verbosity.

If it looks like a package, it’s a package.

If I want to be explicit, I’ll write something in C.

I always squint a little bit when folks mention nanoseconds.

The overheard of observing the time is around 60 nanoseconds.

Light travels about a foot in a nanosecond.

Below ~500 nanoseconds, things get fuzzy.

What’s the protocol actually?

All I can see are hardcoded ping/pong “meow” messages going over a hardcoded client and server.

But maybe the ping/pong is part of the protocol?

It’s not clear.

Anyway, this redundancy-based protocol doesn’t seem to take into account that too many packets over the network can be a cause of bad, “overloaded” network conditions.

Raptorq is a nice addition, though.

Oh, I started searching for some hot topics in the rust lkml, ouch, there’s some bad stuff in there.

Linus seems reasonable in comparison…

I must be missing something obvious. I’m not aware of any too-frequent toxicity in the rust lkml.

Just seems like a lot of groundwork is still being laid, without much even having been started.

The article makes it seem like things are actually being rewritten in rust.

Are they?

Flaregun safely monitors performance metrics on a program, or your whole system.

Like top, it doesn’t require much to Just Work and produce meaningful output.

Like other dedicated tracing tools, Flaregun can peek deeply into your application, extracting metrics like TCP packet and file system latency.

Seems like a good pitch for ai

I once wrote a small piece of software which did everything for everybody in constant time with no dependencies. It was very simple.

I’m wondering if this really is too aggressive.

On Linux, sure it’s not possible to directly crash another program you’re talking to via a socket alone (ignoring bad data on the socket).

But you can absolutely kill them. Anything running as root can kill anything else. Can even reboot and bring down the whole system.

Maybe a bit harder and a bit more unusual, but at least for containers, root privileges are common. And yeah, sure, there’s a cgroup there are you’re more limited. But you get the idea.

It’s also a bit different from the (conventional?) wisdom about being “liberal in what you accept, conservative in what you emit” though that’s a bit more tied to networked systems.

Though, maybe it’s inevitable that a system has to be liberal in what they accept.

How else can you change the api slightly without breaking existing programs?

It’s the integration with those platform-specific requirements which I find so tough. Apple wants a particular format, signed and whatnot via xcodebuild. Windows, I don’t even know. Something about universal apps on the Windows store. Android is a bit simpler if you can target the right directory with the right toolchain.

It’s these particular systems that I find the most difficult. If there were a collection of nice utilities for working with them uniformly, oh, that would be amazing.

- People will happily spend $5 for coffee but have an existential crisis when asked for a $1 app. If you’re looking to make money on these things, it’s an uphill battle.

- All software is derivative. Yours included. Putting it out there is like planting a seed for more to grow, even if it’s just an AI ingesting your work.

- The last two points aren’t mutually exclusive.

Put your work out there in the clear for free, as in freedom, but paid, as in you can get paid. Just don’t expect much.

I wonder if there’s room for a theory of convergent evolution, in software and languages, towards something that is generally appreciated.

Maybe there will always be camps arguing for one thing or another, but together and over the longest term, do they all pull in one general direction?

I’m not so sure I agree with most of the article. The perspective is valuable.

How well does this handle formatted text, like, say, json? yaml? legal agreements?

The ABS system your car’s brakes could crash — literally — and that would be safe?

Without stepping on anyone’s toes, I think we can agree that “safety” could be broken down a bit. Memory safety, thread safety, fine… but there’s a whole forest past those trees.

Is it a safety feature to type-check regular expressions using dependent types? Is Python a security vulnerability because the performance can be unpredictable?

I don’t know.

Rust, for that matter, doesn’t protect you from running out of memory from leaking data on the heap — or from running out of stack space because your infinitely recursive function doesn’t halt. Maybe that’s not part of memory safety — but that’s my point.

There’s a whole safety forest out there. Whenever I read an article about safety in software, it seems like a comfy blanket statement. “This is a nice definition which I will live in.”

I just don’t see how it’s so flat.

Right, that’s my understanding. But OP and a sibling thread here seem pretty sure about the mutex thing.

I think there’s some nuance, but not in the general case.

Shared memory, lazy statics in async blocks, and asynchronous constructors might have different initialization order mechanics that would require synchronization — but even then, the borrow checker would at least point it out