What's in a git merge conflict?

There's something that was bothering me lately about git conflicts:

How come git knows which side is which, and when there is a conflict or where there isn't?

I have the notion of the common ancestor to base the versions off of, but when people do heavy cherry-picking (which is mostly a single branch operation).... how come git reconciles the contents?

Well... as usual, things in git are..... simpler?

https://stackoverflow.com/questions/4920885/what-constitutes-a-merge-conflict-in-git

John Conway's Game of Life

John Conway passed away recently, so let's look at his Game of Life from the APL/J/K perspective.

https://www.jsoftware.com/papers/eem/life.htm
https://news.ycombinator.com/item?id=22845249
https://www.youtube.com/watch?v=a9xAKttWgP4

And a recent ode to J, that explains the first prototype that Arthur Withney and Ken Iverson wrote in an afternoon. I remember having great fun deciphering it 3 years ago on the flights back and from $WORK at that time, and people staring at me reading that printed code and WTFing.

Indeterminate dimensionality

From: http://www.wall.org/~larry/natural.html
 

Scientists like to be able to locate things by giving a ``vector'', that is, a list of coordinates in a space of known dimensionality. This is one of the reasons they like orthogonality--it means the various components of the vector are independent of each other. Unfortunately, the real world is not usually set up to work that way. Most problems, including linguistics problems, are a matter of ``getting from here to there'', and the geography in-between has a heavy influence on which solutions are practical. Problems tend to be solved at several levels. A typical journey might involve your legs, your car, an escalator, a moving sidewalk, a jet, maybe some more moving sidewalks or a tram, another jet, a taxi, and an elevator. At each of these levels, there aren't many ``right angles'', and the whole thing is a bit fractal in nature. In terms of language, you say something that gets close to what you want to say, and then you start refining it around the edges, just as you would first plan your itinerary between major airports, and only later worry about how to get to and from the airport.

Simplicity is its own reward

This is 3 top level hackers discussing about a patch that Stefan proposed to an already solved problem (I guess originally by Daniel, or someone else, but Daniel is anyway the father of the pdump feature).

Amazingly classy and to the point. All 3. I'm learning so much reading this maillist. And still a lot to learn.

Bravo, and thanks.


Stefan Monnier: >> Any objection?
>
Eli Zaretskii: > What are the advantages?  The original problem is solved, and
> everybody agreed that having a dead buffer in the pdumped area is
> nothing we should bother about.
>

Daniel Colascione: With Stefan's patch, Emacs is simpler. Simplicity is its own reward.

Original thread: https://lists.gnu.org/archive/html/emacs-devel/2020-03/msg00922.html

personal journals

 I've been sorta writting a personal engineering journal for some time now, and it's quite valuable. The most productive people I know rule their lives via bullet lists, and journals.

Here are some recent links talking bout them. Also, if you look for org-mode articles, you'll find some interesting workflows.

• https://fs.blog/2014/02/decision-journal/
• https://blog.trello.com/decision-journal
• https://neilkakkar.com/the-human-log.html
• https://neilkakkar.com/How-to-see-Systems-in-everyday-life.html

Links on JITs

If you're interested in JITs, here I leave some recent links that talk about different approaches and techniques. I don't understand many of them, but they might be useful for future reference.

• https://abe-winter.github.io/2020/03/28/jitu-brutus.html
• https://developers.redhat.com/blog/2020/01/20/mir-a-lightweight-jit-compiler-project/
• https://akrl.sdf.org/gccemacs.html
• https://news.ycombinator.com/item?id=22711391

TRAMP with docker is awesome

There's this recent post in reddit where the author shows how to chain tramp connections. And it's great indeed!

What I'm using TRAMP more often for is to login to containers.

Using docker-tramp, I usually browse into a docker and start dired there. But then, I can open a shell (or eshell if there's no bash) there.

And, for example, if you run a postgres container, why not opening a `sql-postgres` buffer?.

Just:

docker run -e POSTGRES_PASSWORD=a -e POSTGRES_USER=rgrau -ti --rm postgres

and when dired-ing through tramp, m-x sql-postrgres using the appropriate params.  Tada!

Neat, ain't it?

Happy hacking, and stay safe.