Go + App Engine =

Hello Gopher!

package gopher

import (
    "fmt"
    "net/http"
)

// The init function is called when your application starts.
func init() {
    // Register a handle for /hello URLs.
    http.HandleFunc("/hello", hello)
}

// hello is an HTTP handler that prints "Hello Gopher!"
func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, Gopher!")
}

Map XML to Go types

<rss version="2.0">
  <channel>
    <item>
      <title />
      <link />
...

type HNFeed struct {
    Data struct {
        Items []Item `xml:"item"`
    } `xml:"channel"`
}

type Item struct {
    Title string `xml:"title"`
    URL   string `xml:"link"`
}

Decode

func hackernewsItems(c appengine.Context) []Item {
    client := urlfetch.Client(c)
    resp, err := client.Get(HNFeedURL)
    if err != nil {
        c.Errorf("Error fetching %s: %s", HNFeedURL, err)
        return nil
    }
    defer resp.Body.Close()
    decoder := xml.NewDecoder(resp.Body)
    var feed *HNFeed
    if err = decoder.Decode(&feed); err != nil {
        c.Errorf("Error decoding HNFeed: %s", err)
        return nil
    }
    return feed.Data.Items
}

And Print

func hackernews(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)
    w.Header().Add("Content-Type", "text/plain; charset=utf-8")
    for _, item := range hackernewsItems(c) {
        fmt.Fprintf(w, "%s: %s\n", item.Title, item.URL)
    }
}

Map Json to Go types

{"data": { "children": [
   {"data": { "title": ... , "url": ...}}, ...

type RedditFeed struct {
    Data struct {
        Items [] struct {
            Data Item
        } `json:"children"`
    }
}

type Item struct {
    Title string `xml:"title"`
    URL   string `xml:"link"`
}

Decode

func proggitItems(c appengine.Context) []Item {
    client := urlfetch.Client(c)
    resp, err := client.Get(ProggitFeedURL)
    if err != nil {
        c.Errorf("Error fetching %s: %s", ProggitFeedURL, err)
        return nil
    }
    defer resp.Body.Close()
    decoder := json.NewDecoder(resp.Body)
    var feed *RedditFeed
    if err = decoder.Decode(&feed); err != nil {
        c.Errorf("Error decoding RedditFeed: %s", err)
        return nil
    }
    items := make([]Item, len(feed.Data.Items))
    for i, item := range feed.Data.Items {
        items[i] = item.Data
    }
    return items
}

And print

func proggit(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)
    w.Header().Add("Content-Type", "text/plain; charset=utf-8")
    for _, item := range proggitItems(c) {
        fmt.Fprintf(w, "%s: %s\n", item.Title, item.URL)
    }
}

Make it concurrent

func progginator_(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)
    results := make(chan []Item)
    go func() {
        results <- hackernewsItems(c)
    }()
    go func() {
        results <- proggitItems(c)
    }()
    w.Header().Add("Content-Type", "text/plain; charset=utf-8")
    for i := 0; i < 2; i++ {
        items := <-results
        for _, item := range items {
            fmt.Fprintf(w, "%s: %s\n", item.Title, item.URL)
        }
    }
}