Go on App Engine Example - Part 1

The App Engine team recently announced support for Go as a runtime for use in apps. Summary up front, the App Engine SDK for the Go runtime is the easiest way I've found yet to get started with Go. As I change my code, it is recompiled in the background when I make a request to my app, so it feels very much like developing in a scripting language.

I've been excited about the Go language for some time now (specifics on why will have to wait for another post) so I was eager to try it out in one of my favorite platforms: App Engine. I wanted to start with something small, so I wrote a simplified version of a web app that I've been itching to write lately, a site for hosting plain text content. Specifically, I want something that preserves whitespace, allows me to line up columns of text, and supports non-English characters (Unicode). Those are the kinds of things I need to share and talk about code. Also there is a great deal more you can do with plain old monospaced text, maybe you'll find this useful as well.

With that objective in mind I give you the Plain Text Machine. This little app lets you enter a small amount of text, somewhere around 2,000 characters, and gives you a link that others can visit to see an HTML reproduction of your writing. I mentioned I wanted to keep this simple, so here's the odd little bit, this app doesn't store your text anywhere. The URL that is generated contains the text, hence the somewhat low limit on message length. It certainly keeps the app simple, the most complex logic is that which converts the text from the URL into HTML.

A request starts by hitting the Init function:

func init() {
 http.HandleFunc("/", handle)
 http.HandleFunc("/show", show)
}

The main page, at /, is just static content, we're just interested in the /show handler. It looks like this:

func show(w http.ResponseWriter, r *http.Request) {
 w.Header().Set("Content-Type", "text/html; charset=utf-8")
 // Get the message from the URL.
 PrintHtml(utf8.NewString(r.FormValue("msg")), w)
}

The above does two things, sets the content type of our response so that the browser will know it is HTML, and reads the message URL parameter from the request to convert it to HTML.

The PrintHtml method prints out some boilerplate HTML then reads the message one character at a time and converts each character to its HTML-safe equivalent. There's a tiny bit of complexity to make sure that the whitespace is preserved instead of being collapsed as would normally be done with repeated spaces in HTML. Here's the code:

func PrintHtml(text *utf8.String, out http.ResponseWriter) {
 spaces := false
 
 fmt.Fprint(out, textHeader, middle)
 for i := 0; i < text.RuneCount(); i++ {
  currentChar := text.At(i)
 
  if currentChar == 32 && !spaces {
   // A first space.
   fmt.Fprint(out, " ")
   spaces = true
  } else {
   if currentChar == 32 {
    // Space following another space
    fmt.Fprint(out, "&nbsp;")
   } else if currentChar == 10 {
    // Newline
    fmt.Fprint(out, "<br>")
   } else if currentChar == 9 {
    // Tab
    fmt.Fprint(out, "&nbsp;&nbsp;&nbsp; ")
   } else if currentChar == 38 {
    // &
    fmt.Fprint(out, "&amp;")
   } else if currentChar == 60 {
    // <
    fmt.Fprint(out, "&lt;")
   } else if currentChar == 62 {
    // >
    fmt.Fprint(out, "&gt;")
   } else if currentChar < 31 || currentChar == 128 {
    // Skip control characters.
   } else if currentChar < 127 {
    fmt.Fprintf(out, "%c", currentChar)
   } else {
    fmt.Fprintf(out, "&#%d;", text.At(i))
   }
   spaces = false
  }
 }
 fmt.Fprint(out, footer)
}

The textHeader, middle, and footer variables are string constants containing the wrapper HTML which gives style information.

If you're interested in the full source code for this tiny little app, you can find it in the Plain Text Machine open source project. Hopefully this example provides an easy to understand picture of what Go code for App Engine looks like.

I had quite a bit of fun putting together this app. By keeping it simple I was able to go from idea to done in less time than it took me to write this blog post. As an added bonus, having an app with no persistent storage brings up some interesting philosophical questions. For example, if a message is created but no one stores the link to it, does it still exist?