[conartist6]

Line and column.

There's 50 years of tech debt in lines and columns which can be traced back through git to patch and then to TTY and to actual typewriters on which you had to feed the paper a line and return the carriage. Line and column are how you break down (and address into) code when code is written on a simulation of a stack of punchcards

[rcxdude]

Interesting, because one of git's philosophies is to not try to be clever about that (in reaction to a general trend in version control at the time of trying to make diffing and merging more clever: Linus felt this just tended to make the breakage less obvious).

[conartist6]

I respect the hell of those philosophies because of how far Linux and git have made it, which they've done by winning people over with good, solid choices. I would hope I'd be a good enough engineer to make the same choices if I saw the same things Linus saw 20 years ago. But it's 20 years later and I'm looking at the next 20 years and I see a different landscape and it causes me to have a different outlook. I think code literacy is a hugely important right now as a battle is fought over whether people will own their technology.

If many people are literate in code, the likelihood is far greater that they will own the tech and it will be open source and built according to principles that make software accountable to them. If most people are illiterate in code, they will become subjects to proprietary technology forced to use products which they have no control over.

The problem is that code literacy hasn't moved beyond the era where developers are people who own a physical keyboard and a full-size computer monitor, use a filesystem regularly, and are able to install and run native applications on their laptop or desktop. But here you've got the next generation of programmers who need to become literate in code (so that they won't become subservient to it) and for many all they have are touchscreens: phones and tablets. Maybe they're on a shared device where they can't or don't want to install software. They might not know what a filesystem or x86 machine code is. That's why I'm on mission to make code literacy and the ability to contribute to open source a matter as simple as having a screen and a browser.

[conartist6]

To reply more directly to the difference in philosophy around merging diffs, I think the git philosophy on preferring to expose potential conflicts rather than glossing over them is basically exactly right, because it creates a system to resolve ambiguity by capturing user intent. If I have any complaint it's that some types of ambiguities are not captured because they are not the result of textually overlapping changes. The canonical example would be a scenario where one developer renames a function and another adds a new usage of it. Git can see no text conflict and so it glosses over the semantic problem. A semantic system would be able to expose not only all the potential conflicts/ambiguities that git can see, but also some that it cannot. And in the case of an add/rename conflict the system should just handle it because the semantic intent of each change was recorded in the system: not "change these 8 call sites" but "change every site that calls this function."

[franktankbank]

I suppose this canonical example would be papered over easily with minimal test coverage.

[conartist6]

Yeah it can be, but you'd really prefer to know without having to go do an exhaustive search I think. The closer to the root cause you catch the problem the easier it will be to tell what happened. Plus, it's not always easy to run exactly the right tests and to run them at exactly the moment they're needed. I usually won't run the whole test suite on each commit if I'm just doing a rebase, say, but it would still be nice if I didn't sail past a problem that I would later have to retrace my steps to fix.

[franktankbank]

The amount of code changes as seen in a git diff is roughly close to the amount of text changes. So reviewing is scaled linear with the change. In the way your are diffing are there any confounding changes? i.e. I make what seems like a small textual diff but it realigns the whole model of the code base that causes your diff to look like a big chunk of your code base is changed? Maybe that's a good thing? Just thinking out loud, I can't say I have an understanding about what your methodology is.

[conartist6]

The methodology is like a codemod or a lint rule. If you've worked with codemods you usually review a combination of the (small) script that describes the intent behind the changes you want and the (larger) diff of (text) changes that were generated by applying the codemod.