That passage bears quoting at length, it's where I really teared up:
> At initiation of ECMO, the boy's rhythm was asystole. The boy was rewarmed with an ECMO heat exchanger-patient gradient ≤10 °C. [...] As the patient's temperature approached 22 °C (72 °F), low-frequency and low-amplitude sinusoidal electrical deflections were noted on his electrocardiogram. As the patient continued to rewarm, these phasic electrical deflections slowly increased in frequency and amplitude. At approximately 28 °C (82 °F), sinusoidal deflections organized into more classic cardiac electrical activity reminiscent of sinus bradycardia with a wide complex. Amiodarone, calcium gluconate, magnesium sulfate, bolus epinephrine, and epinephrine and norepinephrine infusions were administered. After further rewarming, sinus bradycardia developed and ultimately progressed to normal sinus rhythm...
I hear this sentiment a lot, but I've not had a problem with Time Machine in years across multiple MacBooks in my household. Backing up to TrueNAS. Unifi networking. It Just Works.
I just checked any my oldest TM backup for the MacBook from which I'm typing is 2023-09-14. This MacBook has a 2 TB SSD and I have the TM volume quota set to 3 TB. TM culls old backups as needed.
The TM GUI is still terrible, but you can use `tmutil listbackups` to easily access backups from the command line.
I've had all manner of issues, backing up via Ethernet and Wifi to FreeNAS and then to Synology. The only backups with Time Machine I had no issue with were to local USB drives.
Time Machine would work and work and work until one day... "Cannot write to your backup" and the whole thing would be corrupt and not even readable.
Flirted with Acronis TrueImage which was worse. Hell, even before catastrophic corruption, attempting to restore a file from a decent size catalog even over 10gbE would generally cause a beachball for minutes and then you had to be very careful to browse exactly to the location and file you wanted to restore (poking around trying to find it would inevitably totally crash the client, and even being careful sometimes would).
I ended up moving to Carbon Copy Cloner to Synology, with the Synology taking a snapshot 10 minutes before CCC starts its nightly run.
A few months in and it has been rock solid. If I want to restore I can just browse the snapshot in Synology and either copy a file directly from the Snapshot browser or mount the entire snapshot as a shared folder.
Objects are your files. Underlying git is a content-addressable filesystem.
The objects are referenced by trees. A tree is just a directory.
The trees are then referenced by commits and/or tags into a DAG with named pointers into various parts of it (which are your branch and tag references):
Because it would be terribly in-efficient to have a bunch of loose objects, git periodically groups them together into packs. To save space, the objects are compressed against one another (delta compression) within the packs.
When pushing or pulling, the git transfer protocol basically enumerates what objects each side has so that it only needs to transfer the difference. On top of that, it delta compresses the objects on each side that aren't already grouped into packs against each other to save space.
> Because git is an open-source project written by nerds, it shows you all of this information. Feel free to ignore it!
This is the type of attitude that kept most Unix tools quite user-unfriendly for several decades. What information to show the user, and when, are important design decisions to make. Just dumping it all on the user and making them wade through it is not doing the user a favour. Thankfully newer tools seem to be better about this, which has brought the Unix shell forward by leaps, even if there's still ways to go. (You can still make a conscious design decision that the info needs to be all there, and git is one of tools where that's at least somewhat justifiable, but a lot of the time the attitude is more like in the quoted text, that dumping out more info is always better.)
I'm a programmer and I understand Git internals decently well, but unless something went wrong, I pay zero attention to the verbose output of `git push`. BTW, isn't "avoid unnecessary output" one of the Unix philosophies?
And yet, even for programmers, that output is full of info that is useless 99.9% of the time. That is just bad design. It is basically a debug log that is shown by default all the time, instead of written to a log somewhere for the <0.1% time it's useful.
And I point out the attitude because I've seen it for decades and seen the harm this kind of "it's just harmless extra info" type thinking has brought. I don't know what tone you're reading into it, but I'm quite literally and explicitly criticizing the attitude, not you personally.
I dunno, I feel like it's useful output. Sure, maybe you don't need all of the details, but it's effectively a progress indicator to let you know something's happening and it's not "stuck". Why not include useful debug information within the progress indicator so that if something fails part way through a big push, you have useful information for debugging it (or Googling it)?
A percentage information for a network upload is very much not useless information. In fact making the user wait without any indication of progress is very bad UX.
I feel like you’re either misunderstanding the entire thread or being obtuse on purpose.
The point is that “Delta compression using up to 10 threads” means nothing to most users - it’s also not a progress thing. Hide it unless the user does -v or something.
It's not useless information, any more than the tachometer or a temperature gauge instead of an "idiot light" in a car is useless information. Again, "because git is an open-source project written by nerds, it shows you all of this information. Feel free to ignore it!"
If you don't want it, use `--quiet`. I like that it's there by default since it's useful when I need it and ignorable when I don't.
How often do you really need to look at that info while doing normal work?
Because to me and to the very vast majority of git users it is totally irrelevant.
It is nice that the info is available, but the more sane default would be to hide under a verbose flag not the other way around.
Imagine typing cd folder/ and have the whole filesystem subtree be displayed in the terminal. You are free to ignore it, but it is useless and inconvenient nonetheless
Are you not a programmer? Do you not ever find yourself having to debug an issue? When you have to, are you not glad when there's sufficient information in the log files to do so, even though 99.9% of the time you never look at the logs?
> Imagine typing cd folder
It's not comparable. `cd` is a local command (technically a shell built-in) that completes instantly (unless you cd to a hung NFS mount...). So it honors the Unix philosophy of emitting nothing on success.
But cloning is a network operation. And it's normal for networking tools to output progress by default. See `wget` and `curl`.
The problem with hiding progress under `--verbose` is that by the time you need the information (why is this taking so long?), it's too late to add `--verbose`. You'd have to cancel the command and run it again losing progress.
If you don't want it, then use `--quiet` and move on with your day.
(Sure you could make it smarter by deferring outputting anything until it realizes the operation is taking some time. Patches welcomed.)
Now explain this to an artist with very little programming experience beyond what they picked up from their coworkers.
I don't mean to be too glib, but some programmers have this decrepit idea that anyone working with computers should understand programming to be able to fully utilize them.
I worked in gamedev, and many of my colleagues were brilliant, but your comment would read as complete nonsense to many of them. That is the problem git has in the gamedev space. You're trying to manage teams of programmers, designers, sound engineers, gameplay specialists, producers...even c-levels. The parent comment to yours is right, to many many people who work on things that Lore could be useful for would find git to be gobblygook.
I was simply answering niek_pas's rhetorical questions, that's all, because maybe they piqued someone's curiosity and I can contribute a little of my esoteric knowledge about the inner workings of git. This is a site for the curious, yes?
Git is a tool by programmers for programmers. If folks outside the programming community are able to use it, great, but that's not its target audience. You don't need to convince me why git isn't suitable for artists.
I apologize if I came off harsh and combative. Gamedev is a passion for me and I spent many years in that field, including working on proprietary version control systems because existing ones like SVN, Git, Perforce...etc did not fit the needs of the team.
One of the things I very frequently heard from the non-programmer disciplines was how obtuse and indecipherable the existing version control systems were. That is where I'm coming from.
Your knowledge is still appreciated, by me as well, because while I am well familiar with the way git works, I have worked with many people who were not, and did not have the time or budget in their minds for understanding it because they had many other concerns. That is what I mean when I said that I worked with some brilliant people -- I could not do even a modicum of what some of them were capable, and likewise they probably weren't capable of the same modicum of what I was doing.
I don't know what specifically the GP post was trying to insinuate, if anything at all, but it resonated with me as someone who had experienced the same thing many times over in my career. And I probably judged your comment a little harshly on first read, which is mea culpa. You provided good information for those newer to git and seeking to understand how it actually works besides the cheat sheet guides you so often find.
> Git is a tool by programmers for programmers. If folks outside the programming community are able to use it, great, but that's not its target audience. You don't need to convince me why git isn't suitable for artists.
Precisely, and I think Lore is an interesting proposition for exactly that reason.
You know what's a progress indicator? An actual progress indicator. Not some text telling you such and such process is 1234/5678 steps done...followed by yet another line of text telling you that the process is now at step 3 of 20. It could just be a % indicator with a spinning cursor, unless the -v/-verbose flag is present.
Of course artists can learn to understand what all this means; But that is not their job, they have other things to deal with besides the esoteric and overly verbose CLIs we programmers often make.
git is not a particularly suitable VCS for gamedev for reasons so much deeper than what messages it prints for a given command.
git is a tool built to solve versioning text files in a collaborative, open software development context. That is the problem git has in the gamedev space.
> I don't mean to be too glib, but some programmers have this decrepit idea that anyone working with computers should understand programming to be able to fully utilize them.
Git is a software development tool first and foremost to support the development of an _operating system kernel_. It's perfectly reasonable for it to be technically verbose as a default, in the same way as it's reasonable for a band saw to cut off your finger if you use it without understanding things correctly first.
The problem git has in game development is not that the output is too complex, it's that it doesn't handle large binaries well (ironically enough, the focus of the replacement system in TFA).
While I agree that git is a tool for the development of an operating system kernel, it's become clear that this is not the general perception of it. I don't mean those of us who have followed it throughout it's evolution, but those that are not 'in the know'. I have heard probably too many programmers pushing it as the end-all-be-all solution for version control even in environments not appropriate for it.
I will disagree that the output is too complex; it is. And yes, the large binaries issue is also a huge challenge to it's use. There's only so much time in the day, and when you work in gamedev there are often severe pressures to perform, and spending extra time to get into the weeds of a version control system is often not possible without sacrifice.
Yes, then it breaks because you gave your artist an SSH link to clone and LFS requires a HTTPS auth token and exits with terse errors.
Or, you need to lock your files and git doesn't really support that.
To be fair, your hypothetical is true: UE5 supports Git as a backend, you don't need to run git commands (most of the time), but in practice even in the best circumstances: Git for game dev is brittle, slow, and extremely space inefficient.
Worse still: people try pushing their "short lived branches" workflow when using Git, which is *not* how gamedev works, especially for artists. Longer lived changesets are more common. (in Perforce these are called Shelves).
What do you mean about the short lived branches? Long lived branches work just as well in git as anywhere else (and it's easy to keep them mergeable by keep master merged into your branch).
You're basically reinforcing my point which was that the artist argument is a straw man, and companies that need artists to interact with version control will most likely use something else than git.
> artist should use any of the nice frontends that work on top of git and hide its verbosity.
Right up until something goes fucky. You know how many times I got messaged by someone dealing with vcs going wrong for them at a late hour in the evening? If I had a nickel for every time, I wouldn't be rich, but it probably would have bought me a gallon of gas.
It's not the verbosity strictly speaking. It is the minimal level of abstraction between you and the vcs and it can hardly be helped by a 'nice frontend' when things go wrong. And they will; they always do.
> It is the minimal level of abstraction between you and the vcs and it can hardly be helped by a 'nice frontend' when things go wrong. And they will; they always do.
How is this different from any other piece of software ever? When things go wrong, the artist is stuck either way. The only solution is software that always works...
I don't understand - you arguing that artists should learn to use cli? if so, "programmish" git output is not a problem, because they already not just artist, they learned git.
But, for me this looks like this - if artist need to go to cli to solve some error, then this is bug or leaky abstraction in GUI client.
Respectfully, I think you're missing the point. The GP is not asking for an explanation (and could look that up from the Git docs) but commenting on how user-hostile it is. There's lots of software like this, which is so unfriendly that once you've learned the minimum of how to do something and verify it worked, you don't want to touch it any more unless you really need to.
CLI output should be in plain language and omit or minimize unnecessary detail absent a -verbose flag - for example, I'm just not interested in how many threads something took unless I'm working on it. As a user, I want to be focused on the task I'm doing, not on the perfromance of the tool.
I dont think the problem is even verbosity here - it really isnt that much text.
The issue is what you and the above points out - it is not easy to read.
What might help dramatically is a simple modification of text (the verbose stuff could be slightly light grey and the important bits fully highlighted white) or even go full IRC with colored text, bold, etc.
Or hell - maybe instead they add a switch that inserts "//comment" like additionally lines to explain what is going on (succinctly) to the average Power User type. The default could be "software engineer" mode and the switch enable "Git for Dummies" mode.
and why don't we just follow decades of conventions and add a --verbose/-v flag to display all the gobbledegook if you really want to, but hide it by default? As far as I remember, the guidance has always been "only print something if the user needs to know, no output means success."
git would be perfectly usable without knowing how many objects it has pushed or how fast it was doing so.
I'm struggling to understand how this output is a problem. There a whole bunch of things that make git user-unfriendly, but I don't think this is one of them.
I think it's disingenuous to suggest that the `git push` output is somehow adding friction to users. Do you really think that even non-programmer users won't just read it as "it's still doing stuff"? Sure, you could hide it behind a --verbose flag, but then if it fails half way through, it's too late to add the flag. Even a user who doesn't understand the output could then copy/paste it into Google or an LLM to figure out what happened.
Do you know what a rhetorical situation is? Do you understand that the parent was not actually seeking answers to these questions, but was using the questions themselves to make a point about the Git UI?
I was just able to create an account using `rei@<mydomain>` on rei.com w/o any issues. Now, figuring out how to delete the account is another matter entirely...
Cool, they probably changed it, this was years ago. I've had similar issues with other companies, REI is just the only one I can I really recall right now.
I’ll take the under on that bet any day. Maybe around 75% is where I would feel more confident. 25% of a country is more than enough to meaningfully shift perception.
Liquid Glass made my 13 mini consistently lock up and overheat. Multiple reboots every day. Ludicrously slow screen repaints. It only stopped with the latest version (26.5).
Anecdotal evidence is not proof, and as I’ve seen two people in this thread saying the performance of their iPhone 13s improved after iOS 26, I don’t see how you could concretely attribute any of your issues to Liquid Glass specifically (especially since you say it has been resolved with 26.5 despite Liquid Glass still being present in the os).
Not 13 but 13 mini, and it was fine until iOS 26. The symptoms lessened in 26.4 and now seem to be gone. So maybe the "mini" display factor was not sufficiently tested before iOS 26 was released and... it ran into snags (to put it diplomatically).
It was srsly crazy stuff. Screen freeze for a minute, for two minutes, while the battery gets hot enough to cook an egg.
A gazillion-dollar company not throughly testing their software - who'da thunk it ?
[^1]: It was only relatively recently that I learned you can't shock an asystole heart. e.g. https://medicalsciences.stackexchange.com/questions/5874/can...
reply