Applied Web Heresies: ETech 2007

I really wanted to go to Putting the Fun in Functional: Applying Game Mechanics to Social Software by Amy Jo Kim, but my inner geek won out and I went to Applied Web Heresies with Avi Bryant (slides). I hope someone else took good notes.

The basis for the talk is Seaside, a web framework for Smalltalk that Avi wrote several years ago. The problem with Seaside is you’re not going to use it! There are a lot of interesting ideas in Seaside that people should know, so this tutorial is way of spreading the ideas outside of Smalltalk.

Avi suggests using Seaside as a recipe. He tells the story of Primo Levy and onions in the varnish. There are a lot of “best practices” of Web development that were good decisions at the time but which are no longer needed.

Here’s the basic requirement list:

• OOP
• Servlet-style app server
• Blocks and closures

“First thing we do, let’s kill all the templates.” Templates were a good idea that have become useless and harmful. They’re constraining or they’re a bad programming language. The is a belief that templates are useful for model/view separation. But HTML is now a semantic layer and CSS is the real view layer (see Zen Garden). This is an interesting point of view and one I have a hard time arguing with.

So, you need a rich library for generating HTML (see AWT for inspiration). Each widget has a render method that gets a canvas passed to it.

The first thing we did was write a small framework to get things going. Different groups were working in different languages. I used Ruby (even though I don’t really know Ruby). Here’s mine:

require 'webrick' 
require 'stringio' 
server = WEBrick::HTTPServer.new(:Port => 2000) 
server.mount_proc("/heresy"){|req, res| Application.new.handle(req, res)} 
server.mount_proc("/favicon.ico"){|req,res| res.status = 404} 

class Application   
    def handle(req, res) 
        canvas = Canvas.new(res) 
        render_on(canvas) 
    end 
    
    def render_on(html) 
        html.heading("Hello World") 
    end 
end 
  
class Canvas 
  

  
  def initialize(res)
    @res = res
    res['Content-Type'] = 'text/html'
  end
  
  def heading(str, level=1) 
    @res.body = "<h1>"+ str + "</h1>"
  end 
  
end

trap("INT"){ server.shutdown } 
server.start

We’re omitting tag objects here and just spitting out HTML, but a real API should do that.

The next heresy that Avi proposes is that sessions are two valuable to persist. In general, you can never marshall and unmarshall the stuff in memory reliably. All the good stuff’s in memcached anyway. Keep the session in the memory of the application server

What about load balancing? Use sticky sessions. YAGNI Application servers going down is unusual. Users losing session data is a minor annoyance. Live with it.

NeXT’s WebObjects is the inspiration for much of what Avi’s done.

Next we move from our HelloWorld application to something that has stateful sessions. We’re going to build a registry of sessions and push the canvas down a level so that the sessions hold the canvas. My Ruby coding skills were not up to keeping up, so I cheated and grabbed Avi’s code (which includes a much more usable Canvas object):

require 'webrick' 
require 'stringio' 
server = WEBrick::HTTPServer.new(:Port => 2000) 
server.mount_proc("/heresy"){|req, res| Application.new.handle(req, res)} 
server.mount_proc("/favicon.ico"){|req,res| res.status = 404} 

class Registry 
    def initialize 
        @items = [] 
    end 
    
    def register(item) 
        @items << item 
        (@items.size - 1).to_s 
    end 
    
    def find(key) 
        @items[key.to_i] 
    end 
end


class Application   
    @@sessions = Registry.new
    
    def handle(req, res)
        session_cookie = req.cookies.detect{|c| c.name == "heresy"}
        if(session_cookie)
            session = @@sessions.find(session_cookie.value)
        end
        
        unless session
            session = Session.new
            res.cookies << WEBrick::Cookie.new("heresy", @@sessions.register(session))
        end
        
        session.handle(req, res)
    end
end 
  

class Canvas
    def initialize
        @io = StringIO.new
    end
    
    def tag(name, attrs={}, &proc)
        @io << "<"
        @io << name
        attrs.each{|k,v| @io << " #{k}='#{v}'"}
        @io << ">"
        proc.call
        @io << "</#{name}>"
    end
    
    def text(str)
        @io << str
    end
    
    def heading(txt, level=1)
        tag("h#{level}"){text(txt)}
    end
    
    def string
        @io.string
    end
end

class Session 
    def initialize
        @count = 0 
    end 

        
    def handle(req, res)
        @count += 1
        
        html = Canvas.new
        render_on(html)
        
        res.body = html.string
        res["Content-Type"] = "text/html"
    end
    
    def render_on(html)
        html.heading("Hello World: #{@count}")
    end

end

trap("INT"){ server.shutdown } 
server.start

What's left to do on session? Lots, including:

• Unguessable session keys
• Session keys as query params
• Session locks
• Expiration from registry

The next piece of heresy: meaningful URLs don't carry enough meaning. People put a lot of energy trying to create names that describe the particular point in an application. Not every page in an application is a meaningful part of an API. URLs, particularly query parameters are classic place where people repeat themselves. Don't repeat yourself. Lots of meaningless names create namespace collisions.

Avi proposes using a registry to store IDs against page names. The inspiration for this is TCL/TK: Register closures/blocks as callback objects. Here's the code that implements this refinement (I did it almost all by myself--I had to peak to see how WeBrick handled requests):

require 'webrick' 
require 'stringio' 
server = WEBrick::HTTPServer.new(:Port => 2000) 
server.mount_proc(“/heresy”){|req, res| Application.new.handle(req, res)} 
server.mount_proc(“/favicon.ico”){|req,res| res.status = 404} 

class Registry 
  def initialize 
    @items = [] 
  end 
  
  def register(item) 
    @items << item 
    (@items.size - 1).to_s 
  end 
  
  def find(key) 
    @items[key.to_i] 
  end 
end


class Application   
  @@sessions = Registry.new
  
  def handle(req, res)
    session_cookie = req.cookies.detect{|c| c.name == “heresy”}
    if(session_cookie)
      session = @@sessions.find(session_cookie.value)
    end
    
    unless session
      session = Session.new
      res.cookies << WEBrick::Cookie.new("heresy", @@sessions.register(session))
    end
    
    session.handle(req, res)
  end
end 


class Canvas
  
  def initialize(cbs)
    @io = StringIO.new
    @callbacks = cbs
  end
  
  def tag(name, attrs={}, &proc)
    @io << "<"
    @io << name
    attrs.each{|k,v| @io << " #{k}='#{v}'"}
    @io << ">"
    proc.call
    @io << "</#{name}>"
  end
  
  def text(str)
    @io << str
  end
  
  def link(name, &proc)
    id = @callbacks.register(proc)
    tag("a",{ :href=>"?#{id}"}){text(name)}
  end
  
  def space
    @io << " "
  end
  
  def heading(txt, level=1)
    tag("h#{level}"){text(txt)}
  end
  
  def string
    @io.string
  end
end

class Counter 
  def initialize
    @count = 0 
  end 
  
  def render_on(html) 
    html.heading("Hello World: #{@count}") 
    html.tag("p"){html.text("this is fun!!!")}
    html.link("--"){@count -= 1} 
    html.space 
    html.link("++"){@count += 1} 
  end 
end

class Session 
  def initialize 
    @callbacks = Registry.new 
    @root = Counter.new 
  end 
  
  def handle(req, res)
    
    req.query.each do |k,v|
      if callback = @callbacks.find(k)
        callback.call(v)
      end
    end

    html = Canvas.new(@callbacks)
    @root.render_on(html)
    
    res.body = html.string
    res["Content-Type"] = "text/html"
  end
end

trap("INT"){ server.shutdown } 
server.start

As we finished this segment, I said "I get what we're doing, but why are we doing it?" In other words, why go to all this trouble to create a registry of callback methods and URLs that point to it uniquely? The answer is in the next little exercise. Here's the code I produced:

require 'webrick' 
require 'stringio' 
server = WEBrick::HTTPServer.new(:Port => 2000) 
server.mount_proc(“/heresy”){|req, res| Application.new.handle(req, res)} 
server.mount_proc(“/favicon.ico”){|req,res| res.status = 404} 

class Registry 
  def initialize 
    @items = [] 
  end 
  
  def register(item) 
    @items << item 
    (@items.size - 1).to_s 
  end 
  
  def find(key) 
    @items[key.to_i] 
  end 
end


class Application   
  @@sessions = Registry.new
  
  def handle(req, res)
    session_cookie = req.cookies.detect{|c| c.name == “heresy”}
    if(session_cookie)
      session = @@sessions.find(session_cookie.value)
    end
    
    unless session
      session = Session.new
      res.cookies << WEBrick::Cookie.new(“heresy”, @@sessions.register(session))
    end
    
    session.handle(req, res)
  end
end 


class Canvas
  
  def initialize(cbs)
    @io = StringIO.new
    @callbacks = cbs
  end
  
  def tag(name, attrs={}, &proc)
    @io << “<”
    @io << name
    attrs.each{|k,v| @io << ” #{k}=’#{v}’”}
    @io << “>”
    proc.call
    @io << “</#{name}>”
  end
  
  def text(str)
    @io << str
  end
  
  def link(name, &proc)
    id = @callbacks.register(proc)
    tag(“a”,{ :href=>”?#{id}”}){text(name)}
  end
  
  def space
    @io << “ ”
  end
  
  def heading(txt, level=1)
    tag(“h#{level}”){text(txt)}
  end
  
  def string
    @io.string
  end
end

class MultiCounter
  def initialize
    @counters = [Counter.new, Counter.new, Counter.new]
  end
  
  def render_on(html)
    @counters.each{|ea| ea.render_on(html)}
  end
end

class Counter 
  def initialize
    @count = 0 
  end 
  
  def render_on(html) 
    html.heading(“Hello World: #{@count}”) 
    html.tag(“p”){html.text(“this is fun!!!”)}
    html.link(“—”){@count -= 1} 
    html.space 
    html.link(“++”){@count += 1} 
  end 
end

class Session 
  def initialize 
    @callbacks = Registry.new 
    @root = MultiCounter.new 
  end 
  
  def handle(req, res)
    
    req.query.each do |k,v|
      if callback = @callbacks.find(k)
        callback.call(v)
      end
    end

    html = Canvas.new(@callbacks)
    @root.render_on(html)
    
    res.body = html.string
    res[“Content-Type”] = “text/html”
  end
end

trap(“INT”){ server.shutdown } 
server.start

The only changes here are the addition of a MultiCounter class that creates a three item array of counter objects and a render_on object that calls render_on on each member of the array. Then, instead of putting a Counter object at the root, I put a MultiCount object. And you get three of the Counter widgets on the same page. This shows how easy it is to use the objects as Web widgets. Avi says you can’t do this with named URLs.

Avi remarks that pages are a lousy unit of reuse and partials ain’t much better. “But every piece of my application is a beautiful and unique snowflake.” Again, with the CSS.

What aren’t we doing?

• Splitting callback registries up by page view
• Tracking the back-button
• Redirecting after side-effects
• Forms!

Overall this is a very interesting set of thoughts about Web development. Clearly he’s espousing a lot of new ideas, which generated a lot of “How do you …?” questions. Very good stuff. This tutorial made me think, which is the best kind.

Posted by windley on March 26, 2007 2:56 PM