💤🌵🤖

this week at work i am dealing with two different pieces of software that tell me "If You Want An Abstraction Go Fuck Yourself"

one of them is Pigeon Maps, which is nice and doesn't explode all my shit like react-leaflet does, but which insists that all my map elements be direct descendants of the Map, so if I want to break my map elements into three clusters, I can't do

<Map>
  <ClusterOne some="data" />
  <ClusterTwo other="data" />
  <ClusterThree different="stuff" />
</Map>

<Map>
  {clusterOne}
  {clusterTwo}
  {clusterThree}
</Map>

<div>Hi!</div>

const Hi = () => <div>Hi!</div>;
<Hi />

<div>Hi!</div>

<Hi />

the other one is git, which sucks and is bad in many ways, some of which i have blogged a bit about in the past, but the one that bothers me right now is that you can't have abstractions within history. git has an extremely "history is a list of events that occurred in the order that they occurred" mindset, but that's a super useless view of history most of the time.

if i take a history class, they will not just hand me a thousand people's journals and ask me to start reading, that would be deeply silly. someone took that list of events that happened and abstracted out a narrative and put that narrative in a textbook, and i read the textbook and i have a general overview of what happened when but i'm not lost in the individual details. if i then get really curious about one specific moment in time, i can look for a few people's journals and see all the details, but i am not scrolling past a bunch of unrelated bullshit trying to find the detail i actually care about. i get to decide whether to look at the forest or look at the trees, and the forest and the trees both still exist.

git also lets you choose between "see the forest" and "see the trees", but it does it worse. you build the forest out of trees and then the trees no longer exist. it's called "squash" and it's at once

• life-saving, because there are so many trees that the unadulterated full-detail history would be face-meltingly awful to try to make sense of
• horrifying, because if you have more work built on top of this, turning the trees into a forest confuses the hell out of everything and now you have fractal problems and

  git rebase --onto

  will inform you that there is such a thing as a rebase conflict and you have four of them for each change you made in the pre-squashed commits and now it is time to retire and live among the forest creatures

ironically, this is rarely a problem when working alone and only gets gnarly when trying to collaborate. if you want to break up your work into reasonably sized chunks so that someone can review them separately, you are going to wind up splitting your commits into forest-sized pull requests that build on top of each other, but feedback will get incorporated into each pull request independently, so you have to sync up the newer ones so they're built on top of the actual versions of the older ones and then you merge the old ones and the new one is built on the trees instead of the forest so it's rebase conflict time again, and the more work you do and the easier you make it to review, the more often you will go through this nightmare dance.

if the only tools we had for historiography meant that we could not write a history textbook without burning up both the primary sources it was based on and the causal link to future events, it would be a crisis and everyone would be working to build better tools than that so that shit like that didn't happen. but git is still approximately as good as it gets.

Give Me My Fucking Abstractions.