 Good evening. I'm Dieter, I'm the project leader of the Usable Browser. So, what is the UNIX philosophy? There are actually many different interpretations and definitions, but the one that I like the most goes something like write programs that do one thing and that do it well, make them work together and use plain text interfaces because plain text is a universal interface. I really like that definition because that way I end up with applications that are small and that I can integrate and use them as building blocks to define my desktop environment. I don't like applications that do everything at once. I want to integrate things the way I like. Is anyone using something in this list? Raise your hand. All right. Very nice. You will probably like Usable, I think. So, let's start off with some statistics. We started in April last year. During that time, more than 60 people have contributed code or documentation into our Git repository. So, that's even excluding our Wiki. We have now 11,000 lines of codes containing 5,000 lines of C stuff, which is the core, about 5,000 lines of Python code, and then about 1,000 lines of JavaScript and Shell scripts. We have had 13 releases. We follow a release early release often cycle. And there are about 100 scripts available, most of which are on our Wiki. We also include some example scripts in our releases. And people also have some really cool scripts on their blogs. So, Usable is actually about three different applications. There's a Usable core, which is meant for integration. By itself, you probably don't really use it because you need to integrate it with other scripts to make it do useful things. Usable browser is such an example. This is a program that uses the Usable core and it adds a lot of scripts and a configuration file and everything so that you end up with a real browser experience out of the box. But it only shows one page per window. So, that's where Usable tab comes in. It's a solution if you want to see multiple pages in the same window. But you can do a lot more things with this. You can make it into a presentation tool or a news feed reader. There's actually some guy who integrated it into Emacs. It's called Usable or something. So, this is how Usable core looks like. I will do Usable core and then browser and then tapped. As you can see, it's very simple. One WebKit GTK view and one WebKit status bar, which by default just contains the page title and the URL. But you're supposed to put in it whatever you want. So, this is the big overview of how Usable core works. If you get this, then you get most of it. So, this is something that is important. The commands, they are your input into Usable. If you want to change the behavior, change the state, query information, you want to make it do things, you issue a command. The opposite of a command is an event. An event, anytime anything happens, an event is raised. This is just a simple plain text string. It's written on standard output or on a socket file if you wanted to. Obviously, it also has an Xorg interface, either as a normal client, but it also supports XEmbed so you can embed it into other programs. And at the top, you see how you can make Usable interact with web pages, remote ones or local ones, but you can also make it interact with your user space by executing commands, shell scripts, Java scripts, whatever. You can also make it talk to a socket. So, this is how Usable core works. It really bridges all kinds of interfaces together. Some examples of commands. I think they speak for themselves. Load a new page, reload it, zoom, spawn a command. And this one is pretty cool. You can make it raise events with the name that you pick so that if you have an event manager that handles events, you can send events to it to trigger behaviors in your own scripts. Some examples of events. You can see them here. As you can see, Usable core does not handle downloads by itself. It doesn't handle key bindings, for example. Every time you hit the key or you press a button on your mouse, it's just emitting an event which you can then handle. The Usable browser takes Usable core and it puts some useful stuff in the status bar by default. So, just which mode you're in if you have a modal binding, a progress bar, the URL, the name of the instance, which is by default the XOR window ID, but that's not very relevant. So, some features. It comes with a default configuration file so that you have key bindings and that you have your scripts loaded the way they're supposed to so that it works out of the box. You have an event manager which is just a Python script listening on a socket so that Usable core can send its events to it and it has some plugins such as key bindings, a progress bar, tab completion, such things. And also some handlers. You remember the events you just saw? Usable browser will ship some handlers for those events so that you can actually do downloads and so on. Schemes. The last one probably requires some extra attention. This means if you have a URL that starts with IRC colon or mail to URLs like that, it will spawn a script and then you can define however you want to handle such URLs. History and bookmarks. I will demonstrate how that works. Of course, there's integration with your clipboards, pulling things out of it, immediately loading a page from your clipboards, getting the page title in your clipboards. Automatically filling up forms like the password manager in Firefox, for example, but more generic. You can just have a script that says, okay, if the domain is this, then load these fields. You can also edit forms with an external editor. Obviously, page searching and zooming, you get this for free if you use WebKit. Link hinting, I will demonstrate how that works and some more cool things. So, history. How does that work? On the left, you see the on event. That's just a variable which Usable Core will expand for you. So, the string, the second string on the first block is an actual command that Usable Core will interpret for you. So, what it basically means on the event that the load is finished, spawn that script and what that script does, it just echoes the current date and time and the page URL and name into the defined file. As you can see, $6 and $7, those are just parameters that Usable Core will always append when you execute a command so that you just have some useful parameters in your scripts that you can use. How do you pick an entry? First, you define a key binding. This is also a similar variable like the one above. This will be expanded by Usable Core and it will end up in your key binding plugin for your event manager, which will bind your key binding to an execution of the script and that script is very simple. You cut a file in reverse order. You use D-menu to select an entry from it and then you take the URL part from it and then you write into Usable its command interface, which is a FIFO, but you can also use a Unix socket. It doesn't matter. You put the command URI and then change to that URI. So, this is how that looks like picking a URL from your history. What you see here is D-menu. It's a really cool tool. This is a patched version, actually, to show things vertically. So, the matching is similar to how Firefox does it. You type Git and you type Rob and then it will show all pages matching it and if you select it, then it will print it on STD out so you can insert it into Usable Core. This is the link hinting feature. You may have seen this before in Vimperator or Conqueror or browsers like that. What happens, the binding at the top, you first type FL and then any time you hit an extra key, the binding will be executed again. So, you execute the script with this argument. First, your definition of which keys you prefer to use. So, here there are numbers but depending on your keyboard layout, you may want to use different numbers or different characters. And the binding, it will update itself any time you hit the key so that as soon as you match one, it can automatically load the linked page. This is pretty fast. For me, it's much faster than using the mouse to navigate. This is how Usable Tab looks like. It uses the XEmbed feature to embed multiple Usable Browsers. Notice the GTK bar at the top to show where you are. But you can also use different representations. For example, GTK buttons, but we want to really abstract this feature so that you can use a tree or whatever representation you want. Some examples of things you can do. This is the dynamic zooming feature. Basically, what happens if you use a tiling window manager? This is really cool because any time a geometry changed, event occurs, a script will be spawned, and that script will change the zoom level depending on the size of your window. So, as you can see, even this is a spiral layout. Even if your window changes in size, if it gets smaller, the zoom level is adjusted accordingly. So, this is a completely different way of working with multiple instances in comparison to Usable Tab, for example. The bookmark feature is actually very similar to the history feature because it's just a plain text list on each line, a new entry. So, for bookmarks, if you want to store a new bookmark, what you would usually do is you just spawn a script which is bound to a key. You enter your URL. I'm using this entity tool here to enter URL, and it will just write it to a file. But you can also use a built-in feature. When you type console B, it will show a prompt. Not prompt appears here. Then you can enter your tags, and those tags, they will get expanded in the percent S sign. So, when you press enter, it will execute a shell, and in that shell, it will state the command echo and then the current page with whatever tags you typed to the file. And then, of course, if you want to load a page from your bookmarks, you can use something similar to what we did with the history. So, I will put my slides online. Yeah, that's it. So, if you have more questions, shoot.