Web8

Sources at http://sebulbasvn.googlecode.com/svn/trunk/rpyc/demos/web8/

Web8 is a prototype of a concept I came up with, to demonstrate what the "web" ought to become. Since the terms "web2" and "web3" were already taken, I took the liberty to open some distance from this naming scheme and coin the term web8 — browsers, HTML, HTTP, XML, web servers, javascript, ajax, json, templating languages, CSS, DOM, cookies — who needs this Tower of Babel of technologies?

Everything today is too complicated. The basic idea is your client already has a "browser", perhaps better known by the term "GUI toolkit" (GTK/TK/Qt/Win32/ncurses etc.). Instead of trying to encode the application's layout as HTML, control the UI with javascript, keep the logic on the server, implement sessions over cookies, etc. etc. — why not just have the application on the server, and let it display on the client?

Tada! How simple! And this is exactly what web2 does, only it has to go through all of the circles of hell before a single pixel is drawn on the client's screen. This is also what X was meant to do, but somewhere it lost its way and instead we got HTML.

In web8, all you need is a small client-side library that exposes the client's GUI toolkit in a unified and secure way. For example, you wouldn't want the server to be able to create millions of pop-ups on the client, so you wouldn't want to expose a way to create new windows. Other than that, your "web site" is basically a server side application, which you write just like any other GUI application (with a little RPyC skeleton):

class Web8Service(rpyc.Service):
    def exposed_get_page(self, gtk, content, page):
        # gtk is the client's GUI toolkit
        # content is the box in which the server can "draw" (add controls to)
        # page is the "url" of the requested page, for instance "/main"
 
    def page_main(self):
        counter = [0]
 
        # create a label on the client's box
        lbl1 = self.gtk.Label("Hello mate, this is the main page") 
        lbl1.show()
        self.content.pack_start(lbl1)
 
        def on_btn1_clicked(src):
            # this is a function closure, bound to the outer function's scope
            counter[0] += 1
            lbl2.set_text("You have clicked the button %d times" % (counter[0],))
 
        # create a button on the client's box, and attach a server-side event handler 
        # to be invoked when the user clicks the button
        btn1 = self.gtk.Button("Click me!")
        btn1.connect("clicked", on_btn1_clicked)
        btn1.show()
        self.content.pack_start(btn1)
 
        # create another label on the client's box
        lbl2 = self.gtk.Label("You have clicked the button 0 times")
        lbl2.show()
        self.content.pack_start(lbl2)

The amount of technologies you would require to create a simple webapp like this one, using traditional "web2" building blocks, is huge. Try to picture the flow of control.

Web8 is just a prototype of course, and there may still be some holes in it that I haven't thought of, but I'm sure you can see how nicely it plays with RPyC and the "big idea" I'm trying to push: everything boils down to RPC. By the way, web8 is also in the spirit of my upcoming (but unrelated) project, AntiGUI, which aims to automatically deduce the UI for an application. The GUI-programming days are numbered, hip hip hurray :)

Screenshot

Two "web browsers" displaying a "web8 page"