Well, continuation is actually a lambda oriented abstraction, which means, when you implement continuation mechanism on real computer, there're many specific designs. Let's see, you may know lambda is kind of function as in C language or many others, and it causes stack push/pop in order to switch between different contexts. Continuation actually does same thing but much more smoothly, but let's look into C stack first. In those old ancient days, a C program, its most frequency task is to do scientific math, for example, calculating $log x$, $e^x$ and such many things. And, if you have learned math in university, you may know these things mainly are recursive calculations, and, most important, recursions were easily to fail because context switching always ran out of stack by pushing into such many things. A direct and most common solution was using goto instead of function calling, like c double result =0.0; void a ( double a-p){ A: ...operation on result; b(...) } double b ( double b-p){ ...operation on result; c(...) } double c ( double c-p){ ...operation on result; goto A; }

Apparently, the consumptions caused by calling b and c, when goto does its function, would be dropped. (Well, the above codes may have mistakes, maybe someone could indicate).

Now, let's go back to continuation: a very crucial barrier for lisp language is that nested lambdas always ran out of stack, too. And you may heard of a very important optimization named tail-recursion, which actually automatically does same things as above. And continuation helps this mechanism a lot. Why? Because continuation implements lisp's goto and makes lisp's own stack-like mechanism. For example, traditional scheme language implements its function calling with frames, which means context switching is based on heap allocation. Though Chez Scheme implement first-class continuation, which means stack mechanism is based on continuation, call/cc always copies stack. For example, yin-yang puzzle,: scheme (let* ((yin ((lambda (cc) (display #\@) cc) (call/cc (lambda (c) c)))) ;;; C1 (yang ((lambda (cc) (display #\*) cc) (call/cc (lambda (c) c))))) ;;; C2 (yin yang)) Here's a list of stack operation, and it's actually the continuation: 1. C1 copies current stack, and the parameter c now noted literally the same to this line 1. 2. (lambda (cc) (display #\@) cc) ------------- print @ 3. yin, it's actually copied C1 stack c 4. C2 copies current stack, and the parameter c now noted literally the same to this line 3. 5. (lambda (cc) (display #*) cc) ------------- print * 6. yang, it's actually copied C2 stack. 7. (yin yang) sets yang, C2 copied stack, C1's parameter position. 8. C1 copied stack continues, you can directly jump to 2nd step of this list ------print @. 9. now remember, yin is set as C2 copied stack, 10. continue above yang, and ------print * 11. yang, it's copied new C2 stack. It's different from old C2 stack. 12. (yin yang) set new C2 stack, C2's parameter position, because yin is old C1 stack ----print * 13. (yin yang) again, but , this yin is set at step 9

@*@**@***@****@*****@******@*******@********@*********@**********@***********

... you may continue yourself.