Not that you asked, but re: this conversation, I looked at AirTags for cat use and ultimately settled on the TabCat tracker instead. It's pricier, but built for the purpose- the device that goes on the collar is very lightweight and small, and the tracker will guide you via sound right to the cat without the need for relay from other devices like an AirTag. Months of battery life, too.
AirTags have always been "meh" about "finding" anything in motion. And by that I mean the up close "locate this device". I ASSUME it has to do with the fact that its trying to create a multiple point triangulation using only a single device (eg the phone you are on).
Even an airtag moving a little bit, will give you warnings in find my.
They work best for things that a human has to move, and since a good chunk of humans (at least in US/CA) have iPhones, the movement of the physical thing will be tracked by an iPhone fairly reliably. Any time the critter is outside the range of an i-device picking it up the location will be stale. There isn't really a way around that, since GPS/5G radios are a lot more power hungry than the occasional bluetooth pings an airtag broadcasts.
1. they way the network works, it works better for inanimate objects that don't move around
2. they contain small parts that pets might inadvertently eat, and some of the collars that exist for them have been known to snag on things and entrap pets.
I think mostly it's a chew risk for dogs and won't help if the dog is far from the AirTag network. I still have one on my dog anyway (he's not a chewer) and my daughter puts one on her cat occasionally. (Both pets are microchipped too, of course.)
We use them on our cats and have found the trouble-maker cat 3 times out of 3 when needed (in an urban apartment area; most recently the cat was scared by a noise which may have kept her hidden out all night in the cold, unless we had found her/shooed her back to the house)
we have them for our cats, they're great. Sometimes they're hiding in bushes and we don't realize they're 10 ft away. Other times they're down by the neighbor's house. It's not perfect but it tells us which direction more or less. And definitely more peace of mind if they ever got lost. They
They make breakaway collars so if they get caught on something it won't trap them.
I’ve looked at jj, but couldn’t make sense of the proposed benefits. I always stage individual files and never the entire working directory, so I’m confused how it improves that over git.
I've not tried jj yet so I can only speak to impressions, and those impressions appeal to me a lot. My understanding is that jj amends all the changes in _now_ so there's only one place where changes live: the commit graph. No index, no uncommitted worktree. Just commits. And then jj supposedly gives you a lot more freedom to move through and mutate the commit graph directly, rebasing dependent work for you automatically.
So instead of having to `git add -p` several times to pick apart changes from the worktree, the worktree always goes into the graph and you can `jj split` to pick them apart after.
jj split # split latest commit into two
jj edit @- # go back one
jj describe # change message
jj split # whoops, insert commit in the middle
jj edit @+ # move forward again
$EDITOR myfile # do some changes
jj st # amend the changes and show status
jj edit def # jump elsewhere in the graph
jj squash # put two commits together and auto-rebase its descendants
jj new abc # start working after latest
# etc etc
I confess I'm still pretty new to git. I haven't had a very long time to wed myself to git's index and its presence makes me do extra ceremony that I resent whenever I want to polish my graph for my personal projects.
The main difference, it seems, is workflow: git's "prepare then commit" vs jj's "commit then revise".
Currently I do make use of `git add -p` just like grandparent, but I also feel a psychological burden: I will often leave like 3 or 4 separate 2-line changes in the worktree because I don't wanna bother with the ceremony right now, but my perfectionism also resists me putting a lump commit. That's jj's main appeal to me. It amends my work in, then supposedly let's me sculpt it when I'm ready with less of that ceremony.
JJ and Git seem to have different philosophies, so they cater to different users. I want my VCS to do only things I tell it to, so recording things into the index on its own and automatically rebasing commits are not things I actually want.
> I confess I'm still pretty new to git. I haven't had a very long time to wed myself to git's index and its presence makes me do extra ceremony that I resent whenever I want to polish my graph for my personal projects.
Have you realized, that Git versions the index yet? It was written by a filesystem guy, who (I think) considers the filesystem to be a shared space, so Git doesn't consider the filesystem to be its playground. Think of "git add" less of preparing things for the next commit and more of telling git that it can consider some state to be part of its world model. Your repository does not consist of everything below a directory (it can actually span across multiple randomly located directories), it does consist of everything that was once added to the repository.
> The main difference, it seems, is workflow: git's "prepare then commit" vs jj's "commit then revise".
I do the latter just fine in Git, but yes "git add" is a fundamental part of my workflow. I often add some lines already to the index and start writing the commit message, then trying something again in the working directory and either throwing it away or also adding it, before I finally commit. To me the index is a feature.
> but my perfectionism also resists me putting a lump commit
Sounds like you will use a VCS correctly.
> I don't wanna bother with the ceremony right now
I don't know what exactly you consider to be the "ceremony", but I think nearly any git GUI/TUI will let you add lines by selecting with the cursor and pressing a key. The good ones also allow you to edit this. This also works in the opposite way: removing or editing specific lines from an already existing commit. In my experience carefully adding lines results in less mistakes than adding everything and then carefully removing lines, but YMMV.
In addition to my other comment as you wrote you are not familiar with Git yet, some comparison to these commands. You can be in a commit in JJ, while in Git, you are always outside.
'jj edit' seems to correspond to 'git checkout', '@-' is '@~'. '@+' is not possible in Git, because a commit can have an arbitrary amount of children, Git might not even know about, not sure how JJ does this. @~5 is the 5th ancestor, @^5 is the fifth parent, @{5} is this ref five actions ago. This is the ref-log, which you can look at with 'git reflog' or 'git log --reflog'. 'master@{37.days.ago}' also works.
'jj split': use 'git commit --amend' and unselect changes or 'git reset --soft' to an older version, recommit the first part and then take the original commit on top. A git commit consists of a state, not of a diff so putting some commit on top of another that already contains part of the changes results in splitting the former.
'jj describe': 'git commit --amend'
'whoops, insert commit in the middle': just commit
'jj squash': either 'git reset --soft @~2' then 'git commit -c/C' or 'git reset @~' then 'git commit --amend' or 'git rebase' with squash or fixup. The later is possible from some other commit by using 'git commit --fixup' or even 'git absorb' (I think also exists in JJ).
Working in a detached state is fine, but you might want to add a ref (branch or tag, or something else) when you are finished, otherwise Git will eventually garbage-collect them (defaults to 4 weeks to 90 days depending on how you access the commit). You can push just fine to a remote, just specify the branch, i.e. 'git push origin @:branch'. You can also push to local branches to update them without checking them out with 'git push . @~7:feature/something'. Don't use pull, it is stupid, merge when you want to merge, rebase when you want to rebase, but don't do it implicitly as part of fetch.
Ask, if I glossed over something and shall elaborate.
> An IndyCar is heavier than a Formula 1 car: while a Formula 1 car weighs 1759 pounds / 798 kg including the driver, an IndyCar weighs 1700 pounds / 771 kg on road and street courses, excluding the driver.
The statement implies an assumption that the drivers weigh / mass more than 59 lbs. / 27 kg, as they are included in the first measurement, but not the second. This is a reasonable assumption, as even Indycar drivers are all adult males, and none are small enough to weigh / mass less than that.
Isn’t idea of insurance at odds with the idea of a pre-existing condition? Like car insurance is a hedge against a crash. We don’t let people buy it after totaling their car.
We really need an alternative system to cover pre-existing and not force it into insurance.
There is a constant stream of artificially obsolete devices, its a lot of work to keep up with that. Seems like we need a Reverse Engineers Anonymous co-operative to receive hardware and donations and pay people to do the work.
For devices that are connected to internet it should be a best practice at least and probably an obligation to open source the firmware / code that drives the object when the company decides it wants to stop providing security updates.
> At its core, Omarchy embraces Linux . . . makes a version of it that is accessible and fun to use for developers that don’t have a deep background in operating systems.
reply