Teach Yourself Scheme in Fixnum Days (2015)

This one: https://news.ycombinator.com/item?id=17140934

The rest of the program only executes once you apply the continuation. Maybe splitting hairs though.

Perhaps the thinking is that it abstracts both the if branch and the else, and only one of them gets executed?

It is right there in the "Escaping continuations" section. Escaping early means you can use it to write simple things like "drop" and "take", and lazy evaluation. I believe, though I do not know for sure, that this is how lazy evaluation is implemented in lisps, including Clojure.

Also it allows you to write a threading implementation like coroutines in another section below.

Generally it does this: you have a process, say that does A, B, C, D and E. You let it run and save it at, say "C". The continuation is the rest of the process, "D" and "E". So now you go and do something else, say a process from J to U. Somewhere in there, you can whip out your continuation and it does "D" and "E". You are simply bookmarking something to do later because you gotta go do something else.

In coroutines, you run one, stop and save the continuation and switch to another, run, stop, save and switch, and so on and so on, and then jump back and resume the original etc.

Andy Wingo uses delimited continuations to implement guile fibers https://github.com/wingo/fibers/wiki/Manual

It is a low level construct that can be used to build higher abstractions and things like coroutines. In a language like scheme they can also be a (costly) way to do early escapes.

If you are into nondeterminism they are also quite usable.

call/cc is being retired in favour of delimited continuations, which is a good thing.

Most often you don't need them. Implementing things like generators using continuations is possible, but it is also a lot slower than built in support for generators.

Continuations can be used to implement higher-level constructs like exceptions, generators, async calls and so on. For a language like Scheme which prefers a few powerful primitives, it gives the user the power to implement such constructs on their own. Most mainstream languages prefer to keep such powerful tools out of the hands of users, and instead provide higher-level constructs like exceptions, generators, async etc. as part of the core language. It is a trade-off between power and consistency (like macros) - the trade-off which is the stuff of language flame-wars.

There is nothing "mathy" about continuations to my understanding. They are like GOTO, a low-level construct which can be used to implement higher-level constructs which are more appropriate in regular applications. Basically, continuation captures the program counter (the address of the current instruction) and the current environment and stack. This allows you to "save" (like in a computer game) the current execution state, and then restore it as needed.

I didn't see the mobi format listed, but pandoc can create eBooks from TeX source: https://pandoc.org/MANUAL.html https://pandoc.org/epub.html