this is only tangentially related to the article, but I've always found text justification strange. For me paragraphs with ragged edges are easier to read than justified paragraphs, because the irregular ending point helps me keep track of where I am. And justification can lead to some very odd-looking lines. So I've just never quite understood why it's so common in typesetting

One advantage in print; pages are often not entirely opaque. So on page 3, you see a bit of the text of page 2 shine through. If page 2 has a jagged right margin, this also makes the left margin of page 3 look uneven.

Meanwhile, the right margin of page 3 looks has a "shadow" that goes all the way to the right because the left margin of page 2 pokes out underneath it - your eye might want to glide to the end of the block, but the sentence stops earlier.

It looks better when it's aligned, which is also why you can specify a left- and right margin that alternates on odd and even pages.

This is obviously only a concern for books and papers, and not so much for e.g. glossy magazines.

Differences are supposed to convey information. E.g. a paragraph's first line is indented to indicate that this is a start of a paragraph. Differences in line width convey no useful information, so the are suppressed. Same goes for overall text height on a page, although this rule is broken more often.

Typesetters are known to be very specific about small details. E. g. tables are typeset with meticulous alignment rules. It may look superfluous, but it is not. The nature of the craft is that it has to be invisible unless you know where to look.

I've never given this much thought, but I agree with you 100%.

After reading this article I thought "wow that's really impressive and I hate it".

For the same reasons you mention, and the words seem to "blend together" into a blob of text and losing my interest.

Still super impressive that people do this though.

People will bend over backwards to rationalize it but the actual explanation is quite simple: 16th-century typesetters saw it as beautiful, and a norm was born.

IIRC, the somewhat random allocation of trailing silent "e"s in English spelling can partly be explained by typesetters trying to fill lines.

Totally agree with you BTW. I find justification ugly as sin.

It's just neatness. Like ironing clothes or putting on a tie, it's not about it serving a functional purpose. It's just to show off straight lines.

I know, but it feels much more neat to me to have even spacing between words

Fully justified text looks much better when it’s more narrow columns, especially multiple; full page width text is usually not the main use case

I guess in printed material it’s more space efficient, which is why it has historically been used. Justified text can be made look nice but it requires hyphenation and a non-greedy linebreaking algorithm, which unfortunately is not implemented in browsers or Microsoft Word.

Same here, justified text feels difficult to read. And, I had academia where where students are forced to justify text....

calling elon musk "a Republican" is such a wild understatement

what makes TCO so difficult to implement? it feels like it should be a very simple "if the final instruction before RET is CALL, then eliminate the call"

but clearly I'm missing something

In particular it's that if you return the result of a function call, then it's a tail call. For example, in `return f() + g();` neither the call to f() nor the call to g() are tail calls because they return into an expression (`+`) other than `return`.

If you scroll up you'll see a discussion of how the caller does the popping of arguments it pushed, so it has to be the case that if a different number of arguments were needed for a tail call then the caller will still pop the correct number of arguments, and that is where the complexity lies: because the caller does not actually know anything about the called function's tail call details, so how does one cause the correct thing to happen? One way is by changing the calling conventions radically to ensure that either the called function cleans up the arguments before returning, or that the number of bytes to pop is effectively part of the return signature of the function (with the caller somehow being careful to check that the advertised number wouldn't destroy its frame), or just arrange to leave exactly the number of bytes on the stack that the caller expects even if one tail-calls a function that would leave a different number of bytes.

I think saying "nobody has the patience" is assuming that everyone is using agents for hours on end to do enormous tasks. I tend to prompt claude to do smaller, more contained tasks that I understand the entirety of, in which case manual review is straightforward and actually preferred, because I can stop it before it makes a change I disagree with.

I would tend to agree in the case that someone is using LLMs as their primary source for learning. But I've found a lot of use in having a claude project containing the PDF of a textbook I'm working through so that I can ask it to clarify or help me through parts I find confusing. I would definitely say that's greatly accelerated my learning - or at least greatly accelerated the speed at which I integrate information from textbooks.