It says it's just setjmp/longjmp, but later on expands on that, saying you can jump not only up the stack, but down and sideways too (#1).

I think the best explanation (mentioned in the article) is that you take a copy of the entire call stack, and can then reinstate it whenever you want to.

An even simpler explanation is Guy L. Steele's that it's "gotos with parameters", that is, basically goto, but let's you pass a parameter to the destination:

    (define saved-continuation #f)

    (display (string-append "hello "
                (call/cc (lambda (here)
                  (set! saved-continuation here)
                  "world"))
                "!\n"))
    ; Displays: "hello world!"

    (saved-continuation "everyone")
    ; Displays "hello everyone!"

Running it with guile:

    $ guile cc.scm
    hello world!
    hello everyone!

This code makes `saved-continuation` equivalent to

    (lambda (param)
            (display (string-append "hello " param "!\n"))))

Matt Might has an explanation, too: http://matt.might.net/articles/programming-with-continuation...

Finally, we have delimited continuations, which lets you basically slice off a portion of the current call stack, instead of taking it in its entirety. It's more powerful and lets one create true functions, and implement any other control flow construct.

#1: What's often not mentioned is the fact that you can only jump to code you've already run. So you can't jump straight into somewhere your program has not been, yet.