

Continuations - Theyeard
https://curiosity-driven.org/continuations?hn

======
copsarebastards
This is an interesting write-up. This is the first clear explanation I've
found of a situation where I can actually see a use for call/cc that I would
actually use. Unfortunately, languages I use contain nicer sugar for
generators than that (Python being a good example).

I definitely appreciate the the Scheme drive to create abstractions that are
as simple as possible while providing as much power as possible (call/cc is
popularized by Scheme). call/cc certainly does this. But these tools hide a
very complex underlying implementation to the point that it's pretty hard to
understand all the layers. Generators, for example, can be done with a
strategy pattern in object-oriented programming in a way that at first glance
seems more complicated because there's more code, but actually has a very
straightforward translation to the underlying machine code.

Having a very mathematical bent, most of the time Scheme's functional
abstractions "just work". But work with Scheme enough and you'll eventually
hit a problem where they don't (usually a performance issue) and then it
becomes difficult: you end up having to read very deep into implementation
details of the language.

I dunno how this is going to work out. Maybe at some point all the situations
where this stuff doesn't "just work" will be weeded out. But until then, it's
tough to justify my interest in these topics as anything but fun.

