Sven Slootweg (soft-deprecated) @joepie91@pixie.town

@molly0xfff@mastodon.social Is there a link?

As I've been taking Ritalin (generics) for a while now, I've noticed my preference changing a bit - I now like to slightly "underdose" it, and then spike it up a bit with an occasional cup of tea.

This gives me a bit more of an 'ebb and flow' in my mental state, where I don't *constantly* feel one way or the other, but it can fluctuate a bit between 'relaxed focus' and 'slightly chaotic excitement'.

Really seems to help in continuing to feel like myself with eg. excitement for my own projects, while also giving some much-needed rest from a constantly-chaotic brain... while still mostly preventing brain fog!

@davidak@chaos.social Unsure about the name, but it's generally caused by ill-informed hover rules that physically reposition hovered elements, leading to a loop of "hovering" -> "no longer hovering" -> "hovering" -> etc.

Can be prevented by ensuring that the hover state bounding box is always a superset of the normal state bounding box, ie. there are no points on the screen where your cursor 'hits' the bounding box in non-hover state but *doesn't* hit it in hover state.

In cases where a hover effect *must* reposition elements (usually a bad idea for UX reasons), this is often achieved by some combination of padding, background color trickery, and/or a wrapper element that the hover state and interaction handlers are actually defined on (instead of the element itself) - the objective being to 'invisibly' expand that bounding box in the hover state, so that it fully encompasses the non-hover bounding box.

And that makes it all the more irritating when you're one of the few people who *has* actually looked into it, because you end up spending all your time and energy arguing with what essentially boils down to religious beliefs strongly held

Like, the vast vast majority of developers is basically just going off vibes and whatever assumptions/beliefs are considered the social default for their particular programming community, almost nobody has actually looked at what's going on or why

Even if only half the people loudly complaining about software performance and efficiency actually did the work of "understanding where the performance issues come from", things would be so much better right now

@aeva@mastodon.social That's what the original toot is about; trying to target that as a primary objective involves *significant* tradeoffs, that will interfere with other, much more important systemic problems in software that still need to be solved

@aeva@mastodon.social Not really, no; games are a special case where performance is a much higher priority than in most other kinds of software :)

The issues (eg. with dependencies) that I'm describing *do* apply to game development to some degree as well, but the whole recent "we must prioritize efficiency above all" phenomenon is a decidedly non-game thing

@maia "The management level of a shitty company recognizing you by name despite never having worked there" is one of the entries in the Hard Achievement Diary for anti-capitalism

(Another way to look at this, is that "just write efficient code" is an attempt to solve a collective problem with an individualist solution, and I hopefully don't need to explain why that is doomed to fail)

Potentially controversial opinion: I think that "making software more efficient" is the wrong thing to focus on right now.

There's a significant kernel of truth to the idea that "it's easy to make good code performant, but it's hard to make performant code good" - and so before going all-in on optimizing code as the primary objective, we should make sure that we're optimizing the right thing.

And right now, we're not. We're very much not.

There are significant problems to be solved in how we address software development, and the power dynamics embedded into it - the most obvious example would be the still-widespread fear of dependencies, which actively interferes with making software work better for people, and results in an endless treadmill of broken shit.

And guess what, there *are* significant efficiency benefits to be gained here - everybody using the same well-optimized implementation is going to be much better than everybody using their own homegrown half-optimized "clever" implementation.

But by putting all the focus on software efficiency and performance as the #1 priority, we risk removing all the oxygen in the room for figuring out better ways to deal with dependencies and many of the other industry-wide problems I haven't even mentioned here yet, and ending up in a *worse* place (even efficiency-wise!) than where we *could* be if we started with other problems first.

TL;DR: software efficiency and performance is important, but if you treat it as a goal to chase directly, you will end up with broken and faux-simple software that isn't even as efficient as it could be. Fix the big problems with software first, *then* think about how to optimize the remainder.

It's still bizarre how my brain synchronizes with whatever music I'm listening to, even when I'm doing something completely different