Continuations and Web Applications

Cover page image

Continuation

Advanced control structure that is not present in C or Java
Captures a point in a program
Can invoke the continuation and return to the same point later
Low-level feature that can be used to implement higher-level constructs
- Exception handling
- Resumption after curing an error condition
- Iteratively visiting nested structures
- Coroutines
- ...

Control Flow in Web Application

Browser makes HTTP request to server
Server computes result
Server generates HTML response
Browser displays response

How can we implement the equivalent of

cout << "First number: "
cin >> x;
cout << "Second number: "
cin >> y;
sum = x + y;
cout << "Result: " + sum << endl;

Continuation-Based Web Program

Hides the “page flip” from the programmer

(define (start req)
  (let ((num1 (send-and-get "First number"))
        (num2 (send-and-get "Second number")))
    (mk-result-page (+ num1 num2))))

send-and-get
- makes a page prompting for a value
- sends it to the browser
- blocks until the browser sends the answer
- converts the answer to an int
But wait—how does this work?
- Web server has loop waiting for socket connections
- When connection is accepted, data must be sent back to application
- Server keeps map from submission URLs to continuations

Web Programming Basics with Racket

Web program needs a start procedure
Receive request object, return HTML

Use response/xexpr for turning list into HTML

#lang web-server/insta
(define (start request)
  (response/xexpr
   '(html
     (head (title "My App"))
     (body (h1 "Under construction")))))

Dynamic HTML

Use quasiquote for templating
- ` is like ' but you can insert Scheme code inside
- , adds a Scheme value (which can contain nested `)
- ,@ splices in a list of Scheme values

(define (mk-result-page x)
  (response/xexpr
    `(html
      (body
       "Result: "
       ,(number->string x))))))

`send/suspend`

Receives a function that receives the return URL and returns the page text

(send/suspend
   (λ (k-url)
     (response/xexpr
      `(html (head (title "Enter a number"))
             (body
              (form ([action, k-url]) ; Set URL for action attribute
                    "Enter a number: "
                    (input ((type "text") (name "num")))
                    (input ((type "submit")))))))))

Returns the request object that was posted in response

(define (send-and-get msg)
  (string->number 
   (extract-binding/single 
    'num
    (request-bindings 
     (send/suspend (λ (k-url) ...))))))

Implementing `send/suspend`

let/cc is a delimited continuation, denoting the “rest of the computation” until a demarcation defined (in Racket) by prompt
abort returns to the nearest prompt

Place prompt into the dispatch loop

(define (send/suspend mk-page)
  (let/cc k
    (define tag (format "k~a" (current-inexact-milliseconds)))
    (hash-set! dispatch-table tag k)
    (abort (mk-page (string-append "/" tag)))))

`send/suspend/dispatch`

send/suspend's page function gets an URL for continuing
What if a page has more than one link?
send/suspend/dispatch provides a link-making function that you use to encode multiple links

With each link, give a function where the computation continues

(define (mk-count i)
  (send/suspend/dispatch
    (λ (make-url)
       (response/xexpr
        `(html (head (title "Count!"))
          (body
           (a ((href ,(make-url (λ (req) (mk-count (sub1 i)))))) "-")
           ,(number->string i)
           (a ((href ,(make-url (λ (req) (mk-count (add1 i)))))) "+")))))))

Lab

You work with a buddy
One of you (the coder) codes, the other (the scribe) types up answers
Switch roles each lab
The scribe submits lab work to the Sakai site

Step 1. Simple Web App

Start Dr. Racket. Paste the following into the top window and hit the Start button.

#lang web-server/insta
(define (start request)
  (response/xexpr
   '(html
     (head (title "My Web App"))
     (body (h1 "Under construction")))))

What happens?

Add a button or link (your choice) to the page that navigates to http://google.com. What is the code of your web app?

Step 2. Adding

We want to put together the app for adding two numbers. Start with a helper method (mk-number-page prompt url) that generates the Scheme code for
```
<html><head><title>Prompt</title>
<body><form action="URL">
Prompt<input type="text" name="num"/>
<input type="submit"/></form></body></html>
```
Test your code in the bottom pane.

What is your function?
Define a function (send-and-get prompt) that can be used as
```
(let ((num1 (send-and-get "First number")) ...
```
- Use response/xexpr to turn the Scheme HTML from mk-number-page to real HTML
- Use send/suspend to wait for the response
- Extract the num attribute value from the response as shown in the lecture's sample code
What is your function?
Using this function to show the result, complete the start function of your web application. What is the code of the start function?
```
(define (mk-result-page x)
  `(html (body "Result: " ,(number->string x))))
```
Now test your application. It should add two numbers and show the result.
Use the browser's back button and go to the page prompting for the second input. Type a different number. What sum is computed? How was the first number remembered?

Step 3. Navigation

Add a Start Over link to the result page that goes back to the first page.
- You'll need send/suspend/dispatch to make an URL
- mk-result-page needs to make an (a ((href ...)) "Start over")
- You'll need to pass the URL-making function into mk-result-page
- The URL should call a function that computes the sum. Put it all in a function
```
(define (show-sum req) ; We ignore the request
  (send/suspend/dispatch 
   (λ (make-url) 
     (let ((num1 ...) (num2 ...))
       (response/xexpr (mk-result-page (+ num1 num2) make-url))))))
```
- Call that function from start
What is your program now?