See also: https://en.wikipedia.org/wiki/List_of_Germanic_and_Latinate_...

croc's throughput was also a lot better for me. I think this is due to them using multiplexed TCP streams.

Archive link in case it gets taken down: https://archive.is/8MdtL

My favorite aspect of kitty is the infinite scrollback. My scrollback is 10000 lines long and scrollback buffer itself can store 1 GB worth of history.[0] When you hit a certain shortcut, you can use any pager to search through the scrollback. It's all very fast.

[0] https://github.com/siraben/dotfiles/blob/84225d914acd226863e...

Don’t most terminals offer this?

It's pretty common. GNOME's terminal does, as does Kconsole for KDE, and so on. I've got Gnome terminal bumped up to 100,000 lines.

There are definitely some that don't, or don't make it configurable, which for me just gives me pretty strong incentive not to use them.

Yeah, I thought this was a feature of the shell, not of the terminal

It is not

tmux FTW

I often use jump hosts in SSH, but is the only way to do this in mosh to mosh into the relay and then mosh again?

Fractran is a cool esolang that looks impossible to write any programs in at first until you systematically trace through some examples. A while ago I wrote an assembler in Haskell with an optimizer so you can write programs in assembly-style.

  λ> pretty (sumTo 10)
  c += 0
  n += 10
  while n >= 0 {
    c += n
    n -= 1
  }
  λ> runAssembler (sumTo 10)                      -- Program length: 31
  Right [847425747 % 2,13 % 3,19 % 13,11 % 3,11 % 29,31 % 11,41 % 31,23
  % 11,23 % 47,2279 % 23,59 % 301,59 % 41,67 % 413,329 % 67,61 % 59,73 %
  61,83 % 73,71 % 61,71 % 97,445 % 71,707 % 89,103 % 5353,103 % 83,109 %
  5459,5141 % 109,107 % 103,113 % 749,113 % 19,131 % 113,29 % 131,127 %
  113]
  λ> runAsm (sumTo 10)
  [(Prime 97,55),(Prime 107,1)]

You should share link: https://github.com/siraben/hasktran

Replayed it to get a lower time, got 16m 35s.

The crypto prices were so unrealistic. I was able to just keep buying Bitcoin with 2x leverage when it was low and make millions when it subsequently went up after. I barely paid attention to any other ways to make stimulation. Please implement liquidation mechanisms and more volatility.

Yeah it terminates.

A tiny 63 bit program[0] in this language represents a number unfathomably larger than not only ack(9,9), but the far larger Graham’s Number as well. It originates in a Code Golf challenge asking for the “Shortest terminating program whose output size exceeds Graham’s number”, answered by user Patcail and further optimized by user 2014MELO03. With one final optimization applied.

Here's a really short program. Let's calculate 2 * 3

  (λn m s. n (m s)) (λf n. f (f n)) (λf n. f (f (f n)))

eventually it terminates with

   λ s n.s (s (s (s (s (s n)))))

which is just the church encoding of 6.

[0] https://tromp.github.io/blog/2023/11/24/largest-number

A even smaller 49-bit program whose normal form size also exceeds Graham’s Number was found more recently:

    (λJ.J J) (λy.y (y (λg.λm.m g (λf.λx.f (f x)))))

[1] https://github.com/tromp/AIT/blob/master/fast_growing_and_co...

Thanks. A page with examples would be really helpful. The default example (if that what it is) or the shared example would be much more interesting with some context. Or a Show HN, if that’s what’s happening here.

The default page, without including a term does have some explanation

https://lambda-calculus-interpreter.netlify.app/

Patcail made a web game in that theme as well: https://patcailmemer.github.io/Ordinal-Markup/