Show more

@yojimbo @alcinnz
The twist, from the PoV of someone crafting a sci-fi narrative, is that communication back in time is a consequence of the extinction, as illustrated in the Fermi diagram of an electron/positron interaction

While what's theoretically happening at the quantum level is interesting, what happens in the popular imagination is distinct and interesting in its own right

I've been really busy with non-digital duties such as my apartment management dayjob, but hi everyone. When I'm not doing that I'm slowly tinkering with my Raspberry Pis, looking at how to be an ISP of sorts for my building, and helping my partner get ready for their graduate program, which starts next monday. I'm also working on my elisp activitypub server, and tinkering with some essays about things like independence and self-determination and online communication.

@natecull "only after we've assembled"


"Complexity" has numerous characteristics. One is that there well be unintended and unanticipated consequences. THAT this is the case is axiomatic. WHAT they will be you cannot really know until you get there (though these may be fairly clear in hindsight).

And one of those is architectural consequence -- building yourself into a corner that's FANTASTICALLY expensive to build yourself out of.

There may be some patterns.




If you disable zoom on a web page, I will get *physically ill* when I try to zoom gesture on mobile and it doesn't. It literally induces nausea.

It's something about my proprioception system... I tend to extend my physical sense of body beyond my fingertips, into the thing I'm controlling.

And that experience is very unhappy on the modern Web, where things lag for seconds (sending keystrokes to another continent), deny zooming, etc.

(h/t @baldur )

It's clear that Microsoft, with the decline of the desktop market reducing their vice-like grip on the platform, are actively trying to ensure that all computing takes place in *their* cloud. That's why they're killing desktop apps - to tie people into Azure. This is a good antidote:

@natecull Two that I'm becoming increasingly aware of:

1. The Jevons principle, generalised. Changing the costs of something *fundamentally* changes usage patterns. In the sense that new uses *which never existed before* emerge. Often toxic.

2. Hygiene factors. As technologies develop & scale grows, consequences impacting the health of users, the technical ecosystem, and the technology itself, as well as the wider environment, emerge.

Probably more. Gresham's Law.



@dredmorbius @baldur

My Chinese text project, very simple though it is and just a couple of Javascript scripts, is teaching me a lot of interesting things about software development.

It started just with a dataset, and is still driven by that dataset. I don't control the dataset, the dataset is full of holes and contradictions.

Then, I only learn what parts are useful to ME slowly. Because it is LITERALLY Chinese to me, until I learn what each part does.

It's a very literal Chinese Room.

My periodic reminder:

If you see software that's actively marketed to you, it's a guarantee that a) that software is not something you need, b) if you nevertheless "want" it, then it's not the best nor the lowest cost option.

Never trust marketing. Ever. Do your own research to avoid buyer's remorse, or worse.

@natecull ... of understanding it better than most if not all others.

I have a hunch much of the secret of 10x programmers is in that. NOT chasing the latest fads, but developing rich and deep expertise.

A huge problem then emerges when the world passes you by, assuming it ever thought you were Teh New Hawtness at all.

Skill risk.

But yeah: WTF happened to personal programming?



@natecull ... your own warped view of the world, and better yet, *warp the rest of the world to your own way of thinking* (or at least a self-sustaining chunk of it), then you've got two immediate wins:

1. You don't have to fight to understand other maniac(s).

2. You don't have to fight your own inclinations. You can be your own goddamned programming self.

And since what you're producing is an externalisation of your own internal state, you're going to stand a good chance ...



@natecull Going back to the infrastructure point: some people, the ones we think of as hugely productive: Knuth, Torvalds, Carmack. They more-or-less invent (or copy) a system, and then spend their lives developing that.

I've served far more in support roles, _trying to get inside other peoples' heads_. And that's ... hard. And doesn't scale very well. Skull-case domain knowledge either transfers poorly or I've failed to learn the knack of it.

But if you can indulge ...



@natecull ... capitalist gadgets and apps are a whole 'nother matter.

(Presumably, Moore's Law had run its course by 2276 as well.)

But yeah: we end up with a bunch of reinventions on reinvences: A -> B -> BCPL -> C -> C++ -> JAVA

sh -> csh -> ksh -> bash -> zsh

ex -> ed -> sed -> awk -> perl -> (python|ruby)

And others.

With some but comparatively little cross-play. Hell, even Perl5 -> Perl6 or Python2 -> Python3 is migrane-inducing.



@dredmorbius @baldur

I think the explanation for systemd is much simpler:

Red Hat development, as is Windows, is entirely driven by the needs of The Cloud and large-scale computation. Not desktop users.

Cloud users want a whole different set of features from an OS than a desktop user. In fact, they'd be happiest without an OS at all. (And will probably end up there, eventually).

@natecull ... to the community, I commented back that at 56k the download was hours (if not a day or more), and I simply didn't have the free disk space to even stash the tarballs let alone build the damned thing.

There are issues which if you're a well-capitalised (or venture-backed) firm aren't significant, but which if you want to reach out to a community dev model are real showstoppers. Exceeding d/l BW and local storage capacity matters.

OpenOffice stagnated for years.



A new blog post by me:

"Web Dev: The Red Queen Wire Mommy of Modern Tech"

In lieu of a regular weeknote, an attempt to summarise some of the qualms I've been having about the field by drawing comparisons with one of my favourite graphic novels.

@natecull ...worth shit as a back-end / internals dev. Fair with stats, to a point. Flail at UIs.

I think what we've got in, say, Linux, is really a set of distinct communities reaching out toward, but past, each other. Kernel space, the systemd clusterfuckwittedness, "Office" applications.

Note that NeoOffice or whatever the fuck it is this week started as a monolithic proprietary product. And retains much of that stench. When Brian Behlendorf was first reaching out ...



@natecull ... end up with Makers and Users. And those are VERY different communities.

It turns out that software is complex, and complexity is complex, and software is *complexity* itself, or as close to it as we get on this plane.

(Glancing over and seeing your "complexity budget" comment just now. Yes, exactly).

There's no way to look at some codebase and instantly grok it. Even people relatively good at some bits are horrible at others. I'm a decent scripter, but not...



@natecull There's staying the hell out of the way. There's communicating and decisionmaking. All of which at least overlap with "coordination".

There are larger problems. That when you're working with groups, there's no single vision, but a set of overlapping visions, of varying clarity and complexity, and some imposed ceiling *above* which it's hard to climb, which gets *lower* as the community size grows (all else being equal). The Tyranny of the Minimum Viable User.




@dredmorbius @baldur

Also I think the idea of 'complexity budget' is maybe important.

Every line of code (or piece of information, or knowledge) we accumulate builds on other knowledge and is used by other knowledge. That makes it an interface.

Often it's only after we've assembled a knowledge structure that we realise we didn't design it well. But now it's too late to change because other things are now connecting to it.

This problem is not just unique to coding.

@natecull Meantime there's Emacs and Lisp....

I think part of the problem -- a VERY large part -- is that programming simply isn't the simple personal experience it's sussed out to be. Or rather, *software* isn't.

Software is ... infrastructure. It's stuff that's shared amongst a *lot* of people. And when you start doing that, well, you run into all kinds of problems.

Coordination is the least of these, though it's not insignificant.

There's communicating and understanding.



Show more

For people who care about, support, or build Free, Libre, and Open Source Software (FLOSS).