skysight-inc/HackerNews huggingface dataset:
Squashing gets you in the habit of force pushing, and force pushing greatly increases the risk of clobbering someone's work. I've seen a lot more hours wasted on lost commits than I find credible to be wasted in slightly more verbose history.

Squashing also turns cherry picked commits into merge conflicts.

I'm not a fan. I can always go back to the feature PR and read the ticket details and diff commentary when I want the history with a full diff. And of course very old history isn't very relevant because less of it remains in the present, so rot of ancillary systems isn't a huge concern.
But in practice I think it is pronounced cutie, because pretty much nobody cares enough to learn enough Qt lore to know better, and cutie apparently is the most intuitive choice. At any rate, I've never heard anyone pronounce it cute, including people who develop with Qt.
Safer Internet Research Using Containerized Browsers
It's also possible that a company sells their DRM keys during liquidation to someone who is not interesting in actually providing access to the work e.g. a competitor who wants everyone to move to their platform.

It wouldn't surprise me if something absurd happens like Epic buys GOG and then forces you to buy the same games on Epic store again.
The word you’re looking for is evil. Not “scummy”.
Looks real nice! Unfortunately doesn't have graphs like "ali" or other popular load testing tools, and the cloud version is very expensive (starts at $74/month) if you just want some nice visualization of your results.
From the article:

> All costs considered, an operator who makes $5k per month in revenue might take home something like $2k in profit.

That's actually not bad at all.

The issue, as you mention, is that it may be difficult to implement economies of scale. But even 200k for 2 people is something the majority of people would be quite happy with out of a full time job, and considering that this does not require any special degree or training this is very good.
Concatenative Programming; the Free Monoid of Programming Languages (2019)
If you consistently use feature branches and have meaningful summary commit messages in the merge commits as they land on the mainline branch what you're describing is simply:

git log --max-parents=1
git log --min-parents=2

E.g. try this on the git.git repository (not perfect there, since Junio doesn't use this pattern all the time), but it's good enough for a quick demo.

The most useful convention in a DAG like git is to have the topology of your commits reflect your workflow.
>One of the downsides of aggressive ADHD medication treatment is that it can handicap learning of good habits and coping strategies

I mean, my entire post was actually saying the opposite. One of the biggest downsides of having ADHD is the way it handicaps learning of good habits and life skills. I tried doing exactly what you describe in high school and the result was constantly failing to do extracurricular work and being branded as lazy by my peers and educators. There are a lot of comments in this thread on both sides of the argument that seem to take personal anecdote too far. My honest advice continues to be that medication is a great tool for those who need it, and therapy is something pretty much everyone should experience.
That was the one thing that seemed too over the top for me (as a non-native speaker)
I watch Formula 1 and Formula E and in some ways Formula E is better racing. It's more accessible, the cars are all a lot closer in performance and nobody seems to run away with the points.

The problem? The lack of straight line speed means you have to build smaller tracks and a lot of the drama of Formula 1 is missing. You don't feel like you're watching the fastest cars in the world and it feels like a major compromise. If you put those cars on a track built for current Formula 1 cars it's going to be a complete snooze-fest.

What makes racing so attractive to fans is the perception (hopefully not that reality) that these drivers are defying death and/or major injury in pursuit of victory. Even if they're relatively safe, the speed itself triggers the lizard brain inside all of us that keeps most of us from attempting to travel at 200+ MPH.
s7 – Scheme implementation intended as extension language for other applications
Is there a French equivalent anywhere?
When you have to find a subtle one line breakage that happened years ago, you’ll be happy that you had a single commit with 30 lines of code instead of a squashed commit with 3000. It makes it much easier to isolate the case of a problem and fix it in many cases.

I’m asked “how long has this been broken and what caused it?” and answer it via git blame or bisect probably every few weeks. This is life on legacy projects.
Facebook should be shattered into a dozen pieces that are then forced to compete in the social media market.
There are places that keep on doing "open evidence reviews" that summarize key finding in transmission, cures, etc.

Oxford's CEBM is one (https://www.cebm.net) and someone else has posted another for transmission in children here.
I do read the git commit history, and specifically to find problems like these. Squashing commits indeed sounds like a terrible idea to me.

There are also people who insist you always need to rebase your commits before pushing, in order to get a nice, linear history, and again I disagree. It's fine when you're rebasing a very short (single commit) history, but for a long history, it not only gets very tedious, but when it introduces new bugs halfway through that history, you may not notice. You will notice later, and then tracking that bug you end up in the middle of your own (rebased) history and you may wonder why you ever did something so stupid, when the actual cause of the bug was the merge of two histories at the end of your work.

I do rebase sometimes, but only when the history is short and I can easily see what I'm rebasing. A history longer than 2 commits should not be changed.

I never squash.
Fore removing code that's buggy in production. It's way easier to find and remove 1 commit.
I just want to point out that this headline is wrong and out of date already. After pulling out of F1, Honda has announced that they're going to be an engine supplier for Indycar. Technically, it's a different division of Honda (Honda USA) but this greenwashing of why they left F1 leaves a bad taste in my mouth.

They're leaving because they're not successful and they're dumping a bunch of money in the sport.

Edit: I made a mistake they've recommitted to supplying engines under the new hybrid rules that indycar is adopting in 2023.
> Are chassis/aero/suspension innovations relevant to ICE cars?

F1 chassis/aero/suspension innovations are more or less completely irrelevant outside F1. Switching from ICE's to EV's wouldn't change that.
Only existing market leaders are benefiting from coronavirus lockdowns
Newsboat
From experience of working with new CI/CD systems where one doesn't quite understand what's failing due to ... reasons.

It's really quite easy to get into the 50s or close to 100 commits in a branch, which can lead to a horrendously messy history.

There are also people that like to commit before the try something locally and their branches are effectively a mess.

All of the above is magnified in a monorepo environment, where you might have thousands of commits a day against master if it weren't for enforcement policies that force a squash.
> squash merge into shared branches

Why not just rely on a merge commit instead?
The comment says "do something that would cause Amazon to break the contract", not "break the contract myself".
It's something that turned out to be easy and legal to hack on (with businesses that otherwise wouldn't share code being compelled to.)

So the answer is: because people wanted it to be portable.
Vital missed point from the bottom of the article-

Jack Cohen is a retired U.S. Forest Service Research fire scientist who has spent years determining how structures ignite during extreme wildfires. In a September 21, 2020 article he wrote for Wildfire Today with Dave Strohmaier, they addressed how homes ignite during extreme wildfires.

“Surprisingly, research has shown that home ignitions during extreme wildfires result from conditions local to a home. A home’s ignition vulnerabilities in relation to nearby burning materials within 100 feet principally determine home ignitions. This area of a home and its immediate surroundings is called the home ignition zone (HIZ). Typically, lofted burning embers initiate ignitions within the HIZ – to homes directly and nearby flammables leading to homes. Although an intense wildfire can loft firebrands more than one-half mile to start fires, the minuscule local conditions where the burning embers land and accumulate determine ignitions. Importantly, most home destruction during extreme wildfires occurs hours after the wildfire has ceased intense burning near the community; the residential fuels – homes, other structures, and vegetation – continue fire spread within the community.

“Uncontrollable extreme wildfires are inevitable, however, by reducing home ignition potential within the HIZ we can create ignition resistant homes and communities. Thus, community wildfire risk should be defined as a home ignition problem, not a wildfire control problem.”
It depends on the situation. If I'm merging a feature branch that has a lot of commits that effectively make up one feature (because a dev had to go back and forth or because there was a lot of feedback), I might squash those commits into one before I merge it into master.

As mentioned elsewhere in the comments here, that also makes it a lot easier to revert said feature if something goes wrong.
Climbing's Little Helper (2013)
I'm no squash fan either, but git very rarely actually clobbers data. (As long as it's been committed at some point, and wasn't just sitting in the working tree.) `git reflog` can get back pretty much anything, as long as it happened relatively recently.
Ok, so is wealth/status still correlated with bilingualiam if 50% of the planet has that capability?
If git has a concept of branches like mercurial has it would be a lot easier as you can actually see what branch your commits attached to.

(there are pros and cons of both approaches - this is a con of the git approach, I'm not knowledge about enough about esoteric details to comment on if git actually made a bad choice or just a compromise)
Key point readers are missing from the bottom of the article-

Jack Cohen is a retired U.S. Forest Service Research fire scientist who has spent years determining how structures ignite during extreme wildfires. In a September 21, 2020 article he wrote for Wildfire Today with Dave Strohmaier, they addressed how homes ignite during extreme wildfires.

“Surprisingly, research has shown that home ignitions during extreme wildfires result from conditions local to a home. A home’s ignition vulnerabilities in relation to nearby burning materials within 100 feet principally determine home ignitions. This area of a home and its immediate surroundings is called the home ignition zone (HIZ). Typically, lofted burning embers initiate ignitions within the HIZ – to homes directly and nearby flammables leading to homes. Although an intense wildfire can loft firebrands more than one-half mile to start fires, the minuscule local conditions where the burning embers land and accumulate determine ignitions. Importantly, most home destruction during extreme wildfires occurs hours after the wildfire has ceased intense burning near the community; the residential fuels – homes, other structures, and vegetation – continue fire spread within the community.

“Uncontrollable extreme wildfires are inevitable, however, by reducing home ignition potential within the HIZ we can create ignition resistant homes and communities. Thus, community wildfire risk should be defined as a home ignition problem, not a wildfire control problem.”
Backups give you a third thing: immutability.

You can have a nice redundant storage for local performance and resilience, even geographic replication for resilience against a single site loss, but you need snapshots of some kind to protect against replicated destructive updates.
I'm not sure what you mean by that. You can get the APK directly from the Play store with some clever trickery (see the Evozi downloader), but even downloading it from any of the dozen or so mirror sites is secure, if that's your concern, because APKs are signed with the developer's key.

The reason I said "from wherever" is that sharing APKs G Play is a legal grey area and I didn't want to mention one specific way of getting them because there are many, all with different pros and cons.
A 'merge commit' is the commit that ties together two strands.

* merge commit
|\
| * branch work
| |
| * branch work
|/
*

If you squash to merge, typically you're also going to rebase it (equivalently, if it's more familiar, cherry-pick the squash onto the branch your 'merging' it into).

* squash cherry-picked / rebased
| * both branch works squashed
| * | branch work
| | |
| * | branch work
|/_/
*

(In this case the target branch could have been fast-forwarded, but this also works if there's some other work on the mean time:)

* squash cherry-picked / rebased
|
* something unrelated
| * both branch works squashed
| * | branch work
| | |
| * | branch work
|/_/
*
I think Lisbon was on the radar a few years ago, but I get the impression it may have blown it. According to folk I know who were looking at it, they had issues with the 'work ethic' of locals (read into that what you will) and high tax.
I think based on this discussion I can identify one situation where squashing would be good: when you're doing repeated trial-and-error commits on a single file. That way, squashing won't turn it into 3000 lines of code, it just hides the unsuccessful attempts.

But other than that? Small commits please.
Did you see the Note at the bottom?

"The diagram in the title, produced by the postscript code below, is a slightly deformed alternative Y diagram made to look like a Y."

That's not the reason it's called Y combinator though...
> Modification detection can be handled with Magisk Hide, root detection with RootCloak, custom XPosed modules for the sneakier ones.

Not really, if they're not using hardware attestation for Safetynet they will do soon. And even the developer for Magisk believes there's no practical way around that.

https://www.xda-developers.com/safetynet-hardware-attestatio...
And what do you think about the linked article that shows how it's easier to find exactly which code is buggy if you have it in small commits instead of one big squashed one?
Hijacking the top thread to make an important point:

- "Squash your commits" folks - yes, it's good to be able to revert a commit and remove entire features and have a readable commit history.

- "Make small granular commits" folks - yes it's good to be able to bisect and see where exactly some behaviour changed.

Rather than repeat these points (which are both true), there's a better question to be asked:

Should there be a way to have a readable history and keep individual commits? Eg, 'subcommits' etc?

- git may not have these features now, but revision control systems come and go (rcs, cvs, svn, bk, hg, git)

- Or maybe it does. Or we can implement something similar on top of git as it stands.

Discuss.
IMO the better title for the post would be "Unfortunately, I don't setup the clean environment for each of my tests"
Invalid argument. Bacteria exist that can grow in very simple media with low structure. Viruses canmot. They absolutely depend on the existence of a very complex replication machinery.
I agree. Revisiting old content is the rule, not the exception. If there is stuff you really want to watch again you are very likely to pay for it again. There is a game that I played on PS2 that has been ported to NDS and then PC and I bought all versions even though it was the same game every time.
Routinely. Common example that I can't see why anyone would take issue with:

* Commit 1: Fix a bug
* Commit 2: Fix linting issues with the fix discovered through CI
* Commit 3: Remove dead/commented code introduced thrugh commit 1
* Commit 4: Update documents as required by change

I'd always squash those into a single commit before merging into upstream.
Squashing is kind a blunt tool that is useful sometimes, but can be perfectly replaced either by crafting your commits with more care or doing interactive rebasing.

I once had to enforce to an developer that wanted to make 20 commits per PR that were titled like "wip" "wip" "wip" "fix bug" "fix mistake" "format code" in a PR that only changed like 10 lines of code in the end.

In this case, the main problem for me was that git blame became useless because this developer was touching way more lines than necessary and then undoing it using the code formatter.
That's a big discovery. I wonder what motivated the algorithm to explore this space?
How the Sony Playstation PS4 Security Was Defeated
> there's no reasonable way to prevent people from unrestrictedly distributing copies

Why is that a hard requirement though? Also, DRM really doesn't prevent that. I got through my last couple years of college on books from libgen.
I agree. In my humble opinion, the correctness of a word in a given context should be gauged on its utility in communicating a concept. Tomatoes are fruits in a botanical context, but not necessarily in a culinary context. Likewise for the planethood of Pluto, as mentioned elsewhere under this comment.

To hypothesize on a more contentious issue, I think that this ties into contemporary debates on gender identity. The terms "woman" and "man" are ancient and ubiquitous, but only recently seem to be showing as inadequate in certain contexts. Universally defining these terms seems like it would elevate some of these contexts above the others, which would inevitably invite backlash from people for whom these contexts are less common.
I often wonder what kind of impulse drives someone to think, believe, and then confront others with their insanely regressive opinions. At least today I have a concrete answer.

In case you're still confused, there's this thing called the DSM that people use to diagnose/classify mental disorders. It's a pretty big deal.
Most people at my previous place did squash merge on pr completion and we cherry picked quite successfully, so I'd be interested to know how you get to:

> Squashing also turns cherry picked commits into merge conflicts.
Absolutely indispensable app! For laughs I recommend playing with the speed/pitch settings when listening to famous speeches
Just use PCG or XorShift* (in non-cryptographic contexts), they avoid almost all of the pitfalls while still having almost all of the low-overhead benefits

https://www.pcg-random.org/
IIUC, this is close to the english used by the Simple English Wikipedia[0], though it's 1000 words vs 850.

See also, "Thing Explainer: Complicated Stuff in Simple Words"[1] by Randall Munroe (the xkcd author), which explains things using the same set of words.

[0] https://simple.wikipedia.org/wiki/Wikipedia:About#Simple_Eng...

[1] https://xkcd.com/thing-explainer/
> There is nothing about contracts which require that you can only have one active at the same time, or that that current one must be open ended.

Agreed and yet for many systems, that flexability still eludes.

One example I personally experienced was changing a phone contract. The contract had run for many years, so could be cancelled any time with one months notice. The new plan and contract was much better and yet a limitation played out doing this. Ended up that the systems at the telco was unable to activate the new contract until the old contract had ended. Whilst a new contract could be physically signed in a shop with a start date of the day of signing, and logged into the system. The provisioning backed was unable to activate it until the old contract had ceased as you can't have two contracts for the same phone number.

That I do believe is a case of - whilst some things can run in parallel, others are locked to a single dependant resource.

But every rule has an exception, it is with good design that you limit those exceptions impact.
https://etshare.pbworks.com/f/Chapter%2014%20Reference%20Pla... page 5.
There are lots of weird and wonderful vending machines around the world: https://www.straitstimes.com/singapore/live-crabs-and-lego-s...
We already let landlords stop paying. Some landlords are already let off from paying their mortgages during the pandemic. Pandemic mortgage holidays are a thing.

Generally the landlord's mortgage holiday is not being passed on to the tenant though.

If you think the government should pay rent to prevent the banks from losing income from landlords, what's wrong with this simpler system: Tenant stops paying -> landlord stops paying -> government pays the bank?

But it's not really a concern. Unless they really screw up, serious banks don't run out of money at this scale. There are problems from stopping mortgage payments, but "the bank closes" isn't likely to be one.

Same reason you can talk about government covering the rent. The government doesn't have more money than the banks. Its super power is the ability to obtain or create money as needed.

It could give it to tenants to pay landlords, give it to landlords to pay the bank, or give it to the bank directly.

(Btw, I don't think it should give direct to the bank, because people need to cover more than just rent, they need food and other things, and individuals have different urgent priorities which any blanket directed payment would miss. For this reason, I don't think it should pay rent directly either.)
If you use the standard merge commit message in git, then you can still tell what branch things came from when being merged. As someone that has used both mercurial and git, the trouble with named branches (and having to remember to remove them when merging to master) is one of the reasons why I prefer git.
Windows on ARM only allows you to install Microsoft Store apps. Everyone claims ARM is the future but all I see is a proprietary prison.
I'm a big fan of rally racing. It's a fundamentally different model of motorsports -- driver vs. course instead of driver vs. driver -- so there is no overtaking at all, but the action is still far more exciting.
A pool of mirrored pairs is effectively the ZFS equivalent of RAID10.

https://www.klennet.com/notes/2019-08-04-zfs-vs-RAID10.aspx
VC's are predators. Avoid them like the plague. Get your funds from friends, family, and fools unless you are building a nuclear power plant.

Even successful businesses will be destroyed by VC's demanding leverage and higher returns and quick exits.
Also in genealogy:

- estimated dates

- calculated dates (e.g. someone was 30 in 1870, so he was born in "calculated 1840")

- unreadable or unavailable months or days (typically recorded as 1980-00-13)

- time ranges with all of the above as boundaries e.g. "after 1760-03-00 and before calculated 1800"

- plainly incorrect dates, but that's what the document says (1865-02-30)

- no dates (some software tries to enforce putting in some data in for whatever reason)

- dates with unknown calendar
> I'm a simple git revert away from fixing the issue.

I don’t think this is true /just/ for squashed commits as you can simply revert the merge. Squashing is also bad, because you’ll lose the history of the bug fix that prevented the deployment. Or at least someone will have a hell of a time deciphering the PR to reintegrate the original change and your bug fix.

After a few days, weeks, or months, the argument loses even more water because code will likely depend on the commit in question.

War story: there was a time someone accidentally deleted a multi-gb table in production. The table would take hours to delete and replicate globally, so the entire company spent at least an hour deleting the feature from production to stop the database errors. There wasn’t any reverting of original commits. No one had time for that.