[16:39] <dpm> The next day of App Developer Week is starting in ~20 minutes!
[16:39] <dpm> Everyone ready? :-)
[16:46] <jryannel> I'm ready. kind of ;)
[16:46] <dpm> ah, hi jryannel, welcome! :-)
[16:46] <jryannel> thx
[16:52] <nigelb> jryannel: could you also join #ubuntu-classroom-backstage ? :)
[16:59] <dpm> How's everyone?
[16:59] <dpm> Are you all ready for some more development goodness on Ubuntu App Developer Week?
[17:00] <dpm> Ok, let's start the day with one of the newest and coolest technologies in Free Software today:
[17:01] <dpm> Qt Quick, and in particular the QML language
[17:01] <dpm> jryannel, from the makers of Qt knows all about it and will be thrilled to tell you
[17:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[17:02] <jryannel> Ok. Hi I'm jryannel from QtDF acting as Training Manager. This is my first irc training session so bear with me
[17:02] <jryannel> I want to give short intro to Qt Quick's QML language and how to use it
[17:02] <jryannel> First things first
[17:03] <jryannel> You need Qt + Qt Creator, easiest
[17:03] <jryannel> install - QtSDK (http://labs.qt.nokia.com/2011/04/06/qt-sdk-1-1-rc-released/)
[17:03] <jryannel> or on ubuntu search for apt-cache search qt4; apt-cache search creator
[17:04] <jryannel> To run QtQuick you need Qt 4.7.0 or better, latest is Qt 4.7.3
[17:04] <jryannel> or grab it from gitorious
[17:04] <jryannel> So what is Qt Quick?
[17:05] <jryannel> It's based on GraphicsView as 2.5d canvas API with graphics items
[17:05] <jryannel> the graphicsview was developed in c++ and creating rich ui takes a long time
[17:06] <jryannel> So our developers came up with a declarative way.
[17:06] <jryannel> It looks like CSS  or JSON
[17:06] <jryannel> import QtQuick 1.0
[17:06] <jryannel> Rectangle {
[17:06] <jryannel>     width: 360
[17:06] <jryannel>     height: 360
[17:06] <jryannel> }
[17:07] <jryannel> First you import QtQuick module with major and minor version than you define a root element.
[17:07] <jryannel> In this case a rectangle with a width of 360 and height of 360.
[17:08] <jryannel> But live is easier if I don't type a book here;
[17:08] <jryannel> Please visit: http://developer.qt.nokia.com/wiki/Qt_Quick_Tutorial_Basics
[17:08] <jryannel> I will walk you through this and then another example
[17:09] <jryannel> the qmlviewer is the declarative runner for developing purposes
[17:09] <jryannel> it has many options, which you can ask with --help
[17:09] <jryannel> It comes with Qt (in the bin folder)
[17:10] <jryannel> qmlviewer main.qml will interpret the qml file and show the ui
[17:10] <jryannel> The qmlviewer is made with the Qt Declarative module
[17:10] <jryannel> a C++ module. You can write your own declarative viewer
[17:11] <jryannel> see here how: http://doc.qt.nokia.com/4.7-snapshot/qdeclarativeview.html#details
[17:11] <jryannel> It's 3 lines of code
[17:11] <jryannel> QDeclarativeView *view = new QDeclarativeView;
[17:11] <jryannel>  view->setSource(QUrl::fromLocalFile("myqmlfile.qml"));
[17:11] <jryannel>  view->show();
[17:12] <jryannel> That's in essence it the qmlviewer, which interprets the qml file.
[17:12] <jryannel> But back to the qml side of coding
[17:13] <jryannel> width : 300 means a property binding
[17:14] <jryannel> It's different from assignment. It's kind of a contract.
[17:14] <jryannel> So you can write "width:  2 * height"
[17:14] <jryannel> with this width is always 2 times the height.
[17:15] <jryannel> When the height changes the right side will be re-evaluated and assigned to the left
[17:15] <jryannel> Another aspect width:  2 * height" shows:
[17:15] <jryannel> JavaScript. Every right side can contain any kind of javascript code
[17:16] <jryannel> A good javascript tutorial is at
[17:16] <jryannel> https://developer.mozilla.org/en/JavaScript
[17:17] <jryannel> Qt Quick is finally a declartive UI (QML) with C++ backend and JavaScript enhanced
[17:18] <jryannel> Let's jump to "Composition of Components" on the wiki page I posted earlier
[17:18] <jryannel> You can nest qml elements
[17:18] <jryannel> A element has a name and propertis and child elments, like HTMl has
[17:19] <jryannel> (I hope someone is correcting my spelling mistakes later :) )
[17:19] <jryannel> 1
[17:19] <jryannel> 2
[17:19] <jryannel> 3
[17:19] <jryannel> 4
[17:19] <jryannel> 5
[17:19] <jryannel> 6
[17:19] <jryannel> 7
[17:19] <jryannel> 8
[17:19] <jryannel> 9
[17:19] <jryannel> 10
[17:19] <jryannel> 11
[17:19] <jryannel> 12
[17:19] <jryannel> 13
[17:19] <jryannel> 14
[17:19] <jryannel> 15
[17:19] <jryannel> 16
[17:19] <jryannel> 17
[17:19] <jryannel> 18
[17:19] <jryannel> / File: BasicSteps_2.qml
[17:19] <jryannel> import Qt 4.7
[17:19] <jryannel>  
[17:19] <jryannel> Rectangle {
[17:19] <jryannel>     width: 300
[17:19] <jryannel>     height: 300
[17:19] <jryannel>     color: "#FFF8DC"    // cornsilk
[17:19] <jryannel>  
[17:19] <jryannel>     Image {
[17:19] <jryannel>         x: 10; y: 45
[17:20] <jryannel>         source: "voringsfossen1.jpg"
[17:20] <jryannel>     }
[17:20] <jryannel>  
[17:20] <jryannel>     Text {
[17:20] <jryannel>         x: 10; y: 265
[17:20] <jryannel>         text: "Voringsfossen"
[17:20] <jryannel>     }
[17:20] <jryannel> }
[17:20] <jryannel> ohh, sorry
[17:20] <jryannel> so we have a rectangle with an image and text child
[17:20] <jryannel> The child elements have a corrdinate system relative to the parents
[17:21] <jryannel> so a x:10, means 10 px relative to parent.
[17:22] <jryannel> E.g. all elements are derived from the Item element: http://doc.qt.nokia.com/4.7-snapshot/qml-item.html
[17:22] <jryannel> You find an overview about which items are available here: http://doc.qt.nokia.com/4.7-snapshot/qmlbasicelements.html
[17:23] <jryannel> so when you write "x:10" you actually overwrite the default property value (in this case "x:0").
[17:24] <jryannel> For example if you don't  specify a width or height to an element, it will be invisible!
[17:25] <jryannel> Let's come back to "http://developer.qt.nokia.com/wiki/Qt_Quick_Tutorial_Basics" -> Custom Properties
[17:26] <jryannel> besides the default properties you can add own properties.
[17:26] <jryannel> E.g. "property int frameSize: 300"
[17:27] <jryannel> which data types are supported? See here: http://doc.qt.nokia.com/4.7-snapshot/qdeclarativebasictypes.html
[17:27] <jryannel> Can I add own data types. Sure. You can extend Qt Quick from the C++ side: http://doc.qt.nokia.com/4.7-snapshot/qml-extending.html
[17:28] <jryannel> Even you can write own elements. E.g. a chart type or everything what can be painted.
[17:29] <jryannel> Besides visual items you can also use non-visual items, e.g. timer (http://doc.qt.nokia.com/4.7-snapshot/qml-timer.html)
[17:30] <jryannel> And you can also push QObjects from the c++ world into Qt Quick, e.g. for example for a D-Bus binding, or...
[17:30] <jryannel> Now visit shortly http://doc.qt.nokia.com/4.7-snapshot/qml-tutorial1.html for another start into qt quick
[17:31] <jryannel> It's just another hello world in qt quick
[17:32] <jryannel> In Qt Creator our ide you can create a qt quick project with "New Project" -> "Qt Quick UI"
[17:32] <jryannel> If you choose Qt Quick Application, it will generate a C++ qml viewer for you additional
[17:33] <jryannel> So just copy the helloworld from (http://doc.qt.nokia.com/4.7-snapshot/qml-tutorial1.html) in your new project and run the project (no need for compilation)
[17:34] <jryannel> Qt Creator (http://doc.qt.nokia.com/qtcreator-snapshot/index.html) is very much keyboard driven
[17:34] <jryannel> It has also support got git, mercurial and I think svn and some other version control systems
[17:35] <jryannel> Also for pastebin. Which I need to remember to use more
[17:35] <jryannel> Here is a list of shortcuts: http://doc.qt.nokia.com/qtcreator-snapshot/creator-keyboard-shortcuts.html
[17:36] <jryannel> One of our partners has created a reference card: http://www.kdab.com/index.php?option=com_content&view=article&id=126
[17:36] <jryannel> for Qt Creator.
[17:36] <jryannel> But now back to qml...
[17:37] <jryannel> http://doc.qt.nokia.com/4.7-snapshot/qml-tutorial2.html shows how to create a custom qml component
[17:37] <jryannel> A component is a piece of qml code in a separate qml file
[17:38] <jryannel> E.g. if you want create your own button you write a "Button.qml" file
[17:38] <jryannel> Inside would be possible a Rectangle a Mousearea (which receives mouse clicks).
[17:39] <jryannel> In the example tutorial they create a Cell in a "Cell.qml" file
[17:39] <jryannel> The signal keyword allows to emit signal from a qml element. Just by calling the function name
[17:40] <jryannel> The id property is a special property. It allows to identify an element inside a qml file ...
[17:40] <jryannel> ... but also across other qml files.
[17:40] <jryannel> As a convention I always give my root element the "id: root"
[17:41] <jryannel> I give application wide used components a nice name so that I can reference them from other qml files.
[17:42] <jryannel> When referencing an id from another qml file you make yourself depending. So think about if you really want to be dependent on the other qml (component).
[17:42] <jryannel> Id's are only known to the qml runtime when the qml file is actually loaded
[17:42] <jryannel> Have a look at the "The main QML file" section
[17:43] <jryannel> There we use the "Cell.qml" component with a simple call to "Cell".
[17:43] <jryannel> Any qml file (with upper-camelcase" ) in the same folder can be used directly. (Others need to imported)
[17:44] <jryannel> "onClicked: helloText" - is a handler to the signal clicked() from Cell.qml
[17:44] <jryannel> Great. We can make some rectangles and text and place them somewhere so what?
[17:45] <jryannel> With a little bit of C++ and some motivated developers you can make something more ...
[17:45] <jryannel> ... see here http://labs.qt.nokia.com/2011/03/10/qml-components-for-desktop/
[17:46] <jryannel> Jens presents the desktop components (a little bit more complicated Cell.qml with some C++ backend)
[17:48] <jryannel> It's a research project (that's why it's on labs). But I think they will be happy about feewdback
[17:48] <jryannel> But in general Qt Quick is a very much design driven easy to code ui language. Where the heavy lifting is done in C++
[17:49] <jryannel> It's very flexible. With flexibility also comes a price
[17:50] <jryannel> There are many solutions to the same problem. So you need a good practice to master the different elements and C++ extension possibilities to come to a good solution
[17:50] <jryannel> Not every solution is simple and beautiful
[17:51] <ClassBot> There are 10 minutes remaining in the current session.
[17:51] <jryannel> http://doc.qt.nokia.com/4.7-snapshot/qdeclarativeexamples.html here you find more examples
[17:52] <jryannel> Tomorrow we will go into the dynamic side of Qt Quick. Animations - States - Transitions
[17:53] <jryannel> You can find learning material (e.g. videos and whole courses) here: http://qt.nokia.com/developer/learning/elearning
[17:53] <jryannel> I hope I haven't confused you all to much. Qml is simple
[17:53] <jryannel> Elements, Properties, Child Elements,
[17:54] <jryannel> Property Binding
[17:54] <jryannel> and JavaScript + C++ for application logic.
[17:54] <jryannel> Take care.
[17:54] <jryannel> Python and Qt Quick. Yes
[17:55] <jryannel> There is PyQt and PySide
[17:55] <jryannel> checkout: http://developer.qt.nokia.com/wiki/Category:LanguageBindings::PySide
[17:56] <ClassBot> There are 5 minutes remaining in the current session.
[17:56] <jryannel> Sorry question was: Can I use Qt Quick with a python backend instead of C++?
[18:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[18:02] <aquarius> Hi, all!
[18:02] <aquarius> I'm Stuart Langridge, from the Ubuntu One team, and I'm here to talk about our upcoming app developer programme.
[18:02] <aquarius> Do please ask questions throughout the talk: in the #ubuntu-classroom-chat channel, write QUESTION: here is my question
[18:02] <aquarius> and so, on with the show. :)
[18:02] <aquarius> Up until now, your ability as developers to do cool things with Ubuntu One has been limited.
[18:02] <aquarius> But I'm going to change all that.
[18:03] <aquarius> We want to make it possible, and easy, for you to add the cloud to your apps and to make new apps for the cloud
[18:03] <aquarius> So we do all the heavy lifting, and your users (and you!) get the benefits.
[18:03] <aquarius> Imagine, for example, you've made a recipe manager application.
[18:03] <aquarius> So you can type in all the recipes you like to cook, and you've got a permanent record of them.
[18:04] <aquarius> (For me, that would be: get a pizza base; put pepperoni on it. You'll be better at that than me.)
[18:04] <aquarius> Don't really want to take your laptop into the kitchen, though, of course.
[18:04] <aquarius> So, build a mobile app which you sign into with Ubuntu One, and have that show all your recipes too.
[18:04] <aquarius> And a web app which you sign into with Ubuntu One, so that you can look up recipes while you're at a friend's house.
[18:04] <aquarius> This is the sort of thing that we want to make easy; giving your users and you quick access to the Ubuntu One technology.
[18:05] <aquarius> Mobile access to your data; web app access to your data; saving files direct into Ubuntu One; publishing files and photos from all your apps; adding playlists to the Ubuntu One music streaming app; streaming the user's own music into a game you've written.
[18:06] <aquarius> Bringing all that stuff into apps on Ubuntu; Quickly apps or Qt Quick apps or Flash apps or C apps or JavaScript apps or Air apps or whatever you want to develop.
[18:06] <aquarius> We give you the APIs to do it; you build cool stuff. Deal? Deal.
[18:06] <aquarius> This stuff is all being heavily worked on right now as we speak.
[18:06] <aquarius> So this talk won't be too detailed with specifics, because they might change.
[18:06] <aquarius> I want to give you a flavour of what will soon be possible, and answer questions, and give some pointers, and get your thoughts.
[18:07] <aquarius> Also, this is App Developer Week, so I can talk about what the components we're working on are and then admire all the cool ways you all come up with for snapping them together, rather than waiting for marketing to come up with a "product" for you to use :)
[18:07] <aquarius> So, some components that can be snapped together.
[18:07] <aquarius> You'll be able to sign in to a web application with Ubuntu One.
[18:08] <aquarius> This means that you don't have to manage your own identity system, think about password renewal, all that.
[18:08] <aquarius> And that's the hard annoying part of running web apps; working out what to do if a user forgets their password, etc, etc. "Enter the name of your first pet", etc.
[18:08] <aquarius> This is just like "sign in with Facebook" or "sign in with Twitter"; it's OpenID-based, and lets your users sign in to a web app and you'll know their Ubuntu identity.
[18:09] <aquarius> Once you've signed in to an app with Ubuntu One, that app can ask for permission to work with your data.
[18:09] <aquarius> This lets you, developers, build applications that work on the desktop, on the web, on mobile phones.
[18:10] <aquarius> The recipe manager example I mentioned above is one sort of thing you could do, there
[18:11] <aquarius> Your users use the nice recipe manager app on Ubuntu, which you've built with Quickly or whatever you prefer
[18:11] <aquarius> (QML, now that you're all experts in it :))
[18:11] <aquarius> And then they can go to yourrecipemanager.com and sign in with Ubuntu One
[18:11] <aquarius> yourrecipemanager.com then asks them for permission to access their "recipes" database
[18:11] <aquarius> and can then show them all their recipes on the web!
[18:12] <aquarius> Your app (yourrecipemanager.com) does this via OAuth; it goes through the standard OAuth dance to get an OAuth token which can be used to access the user's recipes CouchDB database
[18:12] <aquarius> And your users can be happy that it's secure, because yourrecipemanager.com will only have access to their recipes database; it can't read their contacts, or their files, or their credit card info.
[18:13] <aquarius> So, this gives you the chance to build a brilliant Ubuntu app and yet still extend that app out to other platforms, for people who end up sometimes being away from their Ubuntu machine
[18:13] <aquarius> so they can use the website when they're at work, and the Ubuntu app when they're at home
[18:14] <aquarius> But you can imagine sharing other sorts of data between applications.
[18:14] <aquarius> Imagine, for example, an achievements system.
[18:14] <aquarius> You write a few games; some on the web, some on mobile phones, some on the Ubuntu desktop, some on Windows.
[18:15] <aquarius> And every time the user achieves something in a game, you save that achievement to that user's "achievements" database.
[18:15] <aquarius> ("100 levels completed!", or perhaps "100 enemies killed" if it's that sort of game...)
[18:16] <aquarius> On Ubuntu, you'd save it into desktopcouch, and Ubuntu One will take care of synchronising that into the cloud.
[18:16] <aquarius> On Android, your game would include the DroidCouch library which gives you simple access to save data directly into the user's personal cloud databases.
[18:17] <aquarius> On the web, your game's backend could use the u1couch Python library to do the same thing, save directly into the cloud, or you could just use the underlying REST API (which is just standard CouchDB with OAuth signing; u1couch is just a wrapper)
[18:17] <aquarius> The u1couch library is at https://launchpad.net/ubuntuone-couch for people who want to play with it.
[18:18] <aquarius> it's Python, but it provides a good example of how to take a request to Ubuntu One, discover the user's Ubuntu One tokens, and maek requests using them
[18:18] <aquarius> Or you could write your own wrapper library for PHP or Rails or Flash or whatever you prefer (and then tell me about it so I can point to the documentation for it!)
[18:18] <aquarius> (feel free to use u1couch as a basis, or develop your own if you prefer)
[18:18] <aquarius> At that point, all your games save achievements to the same place, so all your games can show you the achievements you've won in any game
[18:19] <aquarius> And, as before, you can set up yourachievements.com where a user can log in and see all their achievements.
[18:19] <aquarius> There's loads of stuff you can do with shared data.
[18:19] <aquarius> The idea here is that all your stuff is everywhere -- more importantly, all your users' stuff is everywhere.
[18:19] <aquarius> So they get the benefit of all their machines sharing the same information.
[18:20] <aquarius> win an achievement in a game on your Ubuntu laptop, and your Ubuntu netbook also knows you've won that achievement, and which level you got up to
[18:20] <aquarius> and so does your port of the game to a tablet or a web app or whichever other platform you want.
[18:21] <aquarius> and you, developer with limited time, can concentrate on the stuff you're interested in -- making your app, your game, your program -- be great, and just not have to worry about all this data storage stuff.
[18:21] <aquarius> your apps look better because they handle all this, and you don't have to worry about how to do it. :)
[18:22] <aquarius> But Ubuntu One's not just about data.
[18:23] <aquarius> Take the music streaming service, for example.
[18:23] <aquarius> You can currently stream music to Android and iPhone, and you'll be able to add that music to the cloud from Ubuntu and Windows.
[18:24] <aquarius> any music your users have got, that they've purchased from U1 or from elsewhere or ripped from their own CDs or whatever, they sync with U1, and then they can stream it to their mobiles.
[18:24] <aquarius> Maybe you want to be able to stream music back to your Ubuntu machine without syncing it, or your Mac, or your Palm Pre, or your LG mobile phone, or your toaster.
[18:24] <aquarius> So, just use the music streaming API, which is a simple REST HTTP API, based on the Subsonic API, or help people to get at their music by showing them our HTML5 web player for streaming music.
[18:25] <aquarius> But there's more interesting ideas around music streaming than just "listen to the music".
[18:26] <aquarius> Playlists, for example. The Ubuntu One Streaming apps on Android and iPhone know how to create playlists.
[18:26] <aquarius> But how they do that is not a secret. Your playlists are just stored in your cloud databases.
[18:27] <aquarius> So, why not sync your playlists from Banshee or Rhythmbox or Amarok or Exaile or Quod Libet or iTunes or Windows Media Player?
[18:27] <aquarius> (or whichever music player you use yourself. :))
[18:27] <aquarius> Copy the playlists from your media player into desktopcouch on Ubuntu or into the cloud directly with u1couch on Windows or the Mac or anywhere else, in the correct format, and those playlists will instantly show up on your phone!
[18:28] <aquarius> A simple example of this is https://code.launchpad.net/~sil/%2Bjunk/m3u2u1ms/ which is a quick script I wrote to take an m3u playlist and store it in desktopcouch on Ubuntu.
[18:29] <aquarius> the whole script is about 200 lines, so as you can see this isn't hard
[18:29] <aquarius> it just walks through an m3u file, finds a reference to all the songs in it, and creates that as a U1 playlist
[18:29] <aquarius> So you can make your Banshee playlists available to the Ubuntu One app on your Android phone by exporting them as m3u and then importing them with the script.
[18:31] <aquarius> Tighter integration is great, here; what we want to do is to make it easy for you all to build the stuff that you want on top of Ubuntu One.
[18:31] <aquarius> So if you want to have your Amarok playlists available for streaming, it should be possible to do.
[18:31] <aquarius> I rather like the idea of playing a Flash game on the web and having the background music be the most appropriate music chosen from *my* music collection. That'd be cool.
[18:32] <aquarius> Ubuntu One also, as you know, does file sync.
[18:32] <aquarius> But just syncing files is already taken care of by Ubuntu One itself, on Ubuntu and Windows.
[18:33] <aquarius> What's more interesting is working with those files.
[18:33] <aquarius> So, for example, imagine being able to instantly, one-click-ly, publish a file from your application to a public URL and then tweet that URL.
[18:34] <aquarius> Instant get-this-out-there-ness from your apps.
[18:34] <aquarius> The screenshot tool Shutter, for example, can do this already; PrtSc to take a screenshot, then "Export > Ubuntu One".
[18:34] <aquarius> They did a bunch of hard work to do that, and I massively applaud them; nice one Shutter team!
[18:34] <aquarius> Based on what they did, that's the sort of thing that should be easier to do.
[18:35] <aquarius> The shutter team built U1 publishing into their app, and it was harder than it should have been because the APIs were very much in flux, and they weren't very well documented
[18:35] <aquarius> and we recognised that that needs fixing :)
[18:36] <aquarius> So there will be easy-to-use APIs so your apps can do the same. Imagine quickly sharing your newly created image or document or recipe with the world.
[18:36] <aquarius> Your app could have a button to "store all my files in the cloud", or "publish all my files when I save them", or "automatically share files that are part of Project X with my boss".
[18:37] <aquarius> More to the point, you'll be able to work with files directly *in* the cloud.
[18:37] <aquarius> So a backup program, for example, could back up your files straight into Ubuntu One and not sync them to your local machines.
[18:38] <aquarius> that makes it easy for your app's files to be saved away from the local machine if that's what you want
[18:39] <aquarius> which is ideal if you're a backup program, as mentioned
[18:39] <aquarius> so your users can just say "yeah, save this straight into my online storage, I don't need it locally"
[18:40] <aquarius> And of course being able to save things in and out of the cloud means that you can get an Ubuntu One sync solution on other platforms.
[18:40] <aquarius> So you could work with your files from your non-Android mobile phone (we've already got the great mkarnicki working on that for Android!)
[18:40] <aquarius> Build a fuse or gvfs backend for Ubuntu or Fedora or SuSE or Arch Linux. Build a WebDAV server which works with Ubuntu One and mount your Ubuntu One storage as a remote folder on your Mac.
[18:41] <aquarius> so if you prefer to think of your online storage as a drive, rather than something which files are synced to, you can make that happen for yourself and for your users if you want to
[18:42] <aquarius> And web apps can work with your cloud too, for files as well as data.
[18:45] <aquarius> Imagine, say, a torrent client, running on the web, which can download something like a movie or music from legittorrents.info and save it directly into your cloud storage.
[18:45] <aquarius> So you see an album you want on that torrent site (say, Ghosts I by Nine Inch Nails) and go tell this web torrent client about it (and you've signed in to that web torrent client with Ubuntu One)
[18:46] <aquarius> And the website then downloads that NIN album directly into your personal cloud -- which of course makes it available for streaming direct to your phone.
[18:47] <aquarius> You could do that with videos as well: choose a torrentable video (say, Beyond the Game, the documentary about World of Warcraft) and download that directly into your cloud, if someone built the web torrent client.
[18:47] <aquarius> (Of course, that would be cooler if Ubuntu One offered a video streaming service as well as music streaming, wouldn't it. Hm... ;-)
[18:47] <aquarius> But it's not just about your content for yourself; think about sharing.
[18:48] <aquarius> Ubuntu One lets you share a folder with people. This would be great for distribution.
[18:48] <aquarius> Imagine that you publish an online magazine.
[18:48] <aquarius> So, you create a folder on your desktop, and put issues of the magazine in it.
[18:48] <aquarius> Then, you put a button on your website saying "Sign in with Ubuntu One to get our magazine".
[18:49] <aquarius> When someone signs in, your website connects to the Ubuntu One files API, with your private OAuth token, and adds that signed-in user to the list of people that your magazine folder is shared with.
[18:49] <aquarius> Then, whenever your magazine has a new issue, you just drop it into that folder on your desktop.
[18:49] <aquarius> (Or even upload it to Ubuntu One directly through the website.)
[18:49] <aquarius> All the subscribed people will get the new issue instantly, on all the machines they want it on, and in the cloud.
[18:50] <aquarius> No-one has to do anything. No polling of RSS feeds, no bandwidth use by your website
[18:51] <aquarius> You could build a cool Ubuntu app for your readers which would see that a new issue of the magazine has arrived on the machine and lets them read it
[18:51] <aquarius> You could distribute anything like this. Imagine a podcast, or chapters of a novel.
[18:51] <aquarius> It would also work for paid-for content; when someone pays, have your code share a folder with them, and put their paid-for stuff in that folder. That's all doable through the files API.
[18:51] <ClassBot> There are 10 minutes remaining in the current session.
[18:51] <aquarius> We're building the files API itself (an HTTP-based REST API) and also some wrappers for it to make it easier to use in your apps from Python and the like.
[18:52] <aquarius> OK, I've talked about a blizzard of ideas that'll be made possible, and shown you almost no code.
[18:52] <aquarius> Which is because, as mentioned at the beginning, a lot of this code is currently being written and tested as part of the 11.04 release :)
[18:52] <aquarius> However, code is nothing without documentation, and that's really important.
[18:52] <aquarius> My main task for this cycle is to build documentation for all of this stuff; how to use Ubuntu One and all the APIs we provide in the cloud, on Android, on Windows, on iOS, on Ubuntu.
[18:52] <aquarius> So there'll be documentation for all this stuff so all of you clever people can build things that I haven't even dreamed of.
[18:52] <aquarius> We did some user research (thanks ivanka and the user research team!) on which sites have great API documentation and which don't, so we have an idea of good directions to go in.
[18:53] <aquarius> And I'm working away feverishly on getting an alpha version out!
[18:53] <aquarius> So, what I'd like to know is: what are your cool ideas? What help do you need from me in making them happen? What do you want to use Ubuntu One for in your apps and your scripts and your work?
[18:53] <aquarius> and I've got about five minutes left, I think, so I'm happy to answer questions if anyone has any
[18:54] <aquarius> otherwise, thanks for listening and I can hand over to alecu who is going to talk about DBus :)
[18:56] <alecu> hello all
[18:56] <ClassBot> There are 5 minutes remaining in the current session.
[18:56] <alecu> let's wait a couple more minutes and then we'll start
[18:58] <ClassBot> chadadavis asked: What's the best way to stay up to date on the API documentation status?
[18:58] <aquarius> chadadavis, watch the U1 blog where we'll announce that the developer site is available
[19:01] <alecu> hello all
[19:01] <alecu> My name is alecu, some people also call me "Alejandro J. Cura"
[19:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[19:02] <alecu> I'm a developer on the Ubuntu One team, currently working on the desktop side of Ubuntu One.
[19:03] <alecu> For the past year or so I've been using DBus a lot to do bits and pieces of my work, so I'd like to share a bit of that during this session.
[19:03] <alecu> As you all probably know, DBus is a way for applications to request services from other applications.
[19:04] <alecu> For instance, Ubuntu One asks the gnome-keyring daemon for passwords.
[19:04] <alecu> Or the sound menu asks the music players to start playing or to change tracks.
[19:04] <alecu> so, let's dive into an example...
[19:04] <alecu> for this we need to have d-feet installed
[19:05] <alecu> sudo apt-get install d-feet
[19:05] <alecu> so, everybody has d-feet installed by now?
[19:06] <alecu> open it, and let's browse the Dbus bus a bit
[19:06] <alecu> go to File -> Connect to Session
[19:06] <alecu> and we will be able to explore the Session Bus
[19:07] <alecu> on the left we have a list of Bus Names. It's common for each application that's providing a service to use one, but some apps export more than one Bus Name.
[19:07] <alecu> clicking on one of the Bus Names, we'll see a list of Object Paths on the right
[19:08] <alecu> it's very common for one application to export more than one Object Path
[19:09] <alecu> if you click on one Bus Name and no object paths appear, that means that the application is not providing introspection data, and that means that we'll need to ask the app developers for more info on how to use those services thru dbus.
[19:09] <alecu> but the common case is to have both introspection data and some dbus documentation...
[19:10] <alecu> let's look at one example
[19:10] <alecu> let's open banshee, or some rhythmbox
[19:11] <alecu> when we run banshee, we'll see on d-feet that a new "Bus Name" was published to provide services to other apps
[19:11] <alecu> try clicking on d-feet on it: org.bansheeproject.Banshee
[19:12] <alecu> on the right hand we'll see a few Object Paths
[19:12] <alecu> let's open /org/mpris/MediaPlayer2
[19:12] <alecu> and open the "org.mpris.MediaPlayer2.Player" interface
[19:13] <alecu> Inside that interface we'll see a list of Methods, Properties and Signals
[19:13] <alecu> let's try one Method: play
[19:13] <alecu> sorry, Play()
[19:14] <alecu> double click on it, and a new small window opens "Execute D-Bus Method"
[19:14] <alecu> just click on Execute
[19:14] <alecu> banshee should start playing
[19:15] <alecu> (if it does not, try making it play some song by hand, then pausing it thru d-feet)
[19:17] <alecu> and then try playing with the other methods
[19:17] <alecu> for instance, Seek takes a parameter, try 30000000
[19:18] <alecu> or -30000000
[19:18] <ClassBot> chadadavis asked: there are a few 'play' methods under other object paths. Why are there so many? What's the difference, in the case of banshee here?
[19:18] <alecu> chadadavis, you mean Play and PlayPause?
[19:19] <alecu> I think Play always plays, but PlayPause is like a toggle.
[19:19] <alecu> chadadavis, the thing is that I don't know exactly how that works, and since it won't be documented in a DBus browser like d-feet we need to find some spec
[19:20] <alecu> and I was just pointing all of you to this example, because there's a lovely documentation for this interface, and it's common to many-many media players.
[19:21] <alecu> it's http://xmms2.org/wiki/MPRIS
[19:22] <alecu> and for the work I've been doing for the gnome-keyring and kwallet, I've been using the "Secrets Service API" http://people.collabora.co.uk/~stefw/secret-service/
[19:23] <alecu> so you'll probably need some similar docs for the service you are trying to use
[19:23] <alecu> or just use an explorer like d-feet to experiment with the interface you want.
[19:24] <alecu> So, after finding some service that you want to use, and some docs on it, you'll want to use DBus from your own application.
[19:24] <alecu> I've mostly used python for this, but I understand that other bindings are similar.
[19:25] <alecu> Here's a few examples I've made, so we can go over:
[19:25] <alecu> bzr branch lp:~alecu/+junk/dbus-lessons
[19:26] <ClassBot> crazedpsyc asked: if credentials are transported through DBus, can't I, or anyone else see them by using something like dbus-monitor?
[19:27] <alecu> crazedpsyc, there is one instance of DBus running for the system, and an instance per user that's logged in.
[19:28] <alecu> crazedpsyc, DBus connections are always local, and are either in the context of your computer or your session.
[19:28] <alecu> crazedpsyc, there are security rules on the system DBus, so apps are limited on what they can listen to.
[19:29] <alecu> crazedpsyc, for the session DBus I haven't seen any security restrictions, so afaict any app can listen for all the Dbus traffic for every other app.
[19:30] <alecu> crazedpsyc, that includes listening for the same logged in user credentials, but any X window app can capture all keystrokes anyway, so there's no point in securing that.
[19:30] <alecu> crazedpsyc, makes sense?
[19:31] <alecu> crazedpsyc, we can discuss this on much detail later, since app sandboxing is an issue I find very interesting to work on.
[19:32] <alecu> anyway, let's go back to the samples
[19:32] <alecu> let's look at the first one: 01-call_method.py
[19:34] <alecu> DBus usually has to work together with the main loop of your application
[19:34] <alecu> usually it's the gtk or kde main loop, and DBus supports it.
[19:34] <alecu> But you can also use the twisted reactor as a main loop, and we'll be able to integrate that as well.
[19:35] <alecu> in this example I'm using the gobject main loop, as used by gtk.
[19:35] <alecu> this line joins dbus with the loop: "DBusGMainLoop(set_as_default=True)"
[19:36] <alecu> and on the following lines we get at the "Session Bus", get an object from it using a "Bus Name" and an "Object Path"
[19:36] <alecu> and we get an "Interface" from that object.
[19:36] <alecu> as you can see, it all matches what we are able to see on d-feet.
[19:37] <alecu> once we get an Interface, we can call on the Methods on it, and access its Properties
[19:38] <alecu> in this example I'm just changing the brightness of my laptop display, and depending on your hardware it might not work.
[19:38] <alecu> So I'll ask you all for homework to modify it so it changes the volume of the music player.
[19:39] <ClassBot> psusi asked: What is the use of naming the Interface of an object separtely from the name of the object itself?  Can this be used to publish versioned interfaces to, for instance, add a new argument to a signal without breaking applications that depend on the interface without the argument?
[19:41] <alecu> psusi, exactly. We can add more than one interface for an object, to group interfaces per intent, so for instance the MPRIS spec separates the methods in the Player from the Playlist interfaces, and also as you very correctly point out to create a new interface and not break compatibility with older interfaces.
[19:42] <alecu> Ok, let's look a bit further into arguments for the Methods
[19:43] <alecu> since DBus is language agnostic, it defines a way to specify the types of the arguments and return values of DBus Methods
[19:44] <alecu> each language binding will try to match it to native types. For instance the python binding will usually transform DBus byte arrays into python strings
[19:44] <alecu> (python 2 strings, that is :-) )
[19:45] <alecu> so Dbus has a way of specifying a small string that will act as the signature for the types in a DBus method call
[19:47] <alecu> for instance let's browse with d-feet the org.mpris.MediaPlayer2.Playlists interface
[19:47] <alecu> the GetPlaylists method has a very complicated signature
[19:47] <alecu> Uint32 index, Uint32 maxcount, String order, Boolean reverse_order
[19:48] <alecu> in dbus you'll usually see this as "uusb"
[19:49] <alecu> and the return value for that method is array of [struct of (object path, string, string)]
[19:49] <alecu> you'll see it defined as "a(oss)"
[19:50] <alecu> for a complete reference of this, and much more, try this tutorial: http://dbus.freedesktop.org/doc/dbus-python/doc/tutorial.html#data-types
[19:50] <alecu> we'll need to define strings similar to this when we export our own objects on DBus as services
[19:51] <alecu> so let's look at example 03-export_object.py
[19:51] <ClassBot> There are 10 minutes remaining in the current session.
[19:52] <alecu> in this example I'm exporting a DBus object on a given "Bus Name" and with a given "Object Path"
[19:52] <alecu> and when I run the example, I can use d-feet to call the example_method. Go ahead, try it.
[19:53] <alecu> In addition to the Method, I'm also exporting a "Signal"
[19:53] <alecu> Signals work backwards
[19:54] <alecu> Usually a dbus client calls a method.
[19:54] <alecu> But the clients subscribe to signals, and the dbus service calls them.
[19:54] <alecu> We can see how to subscribe to a signal in example 2
[19:55] <alecu> in 02-listen_signal.py we connect to the bus, and using a "Bus Name", an "Object Path" and an "Interface", we connect a function of our code to a DBus signal.
[19:56] <ClassBot> There are 5 minutes remaining in the current session.
[19:56] <alecu> in this example I also use the BackLight, but as homework as well you may change listen to media player signals as well.
[19:57] <alecu> ok, this was a brief overview of how to use DBus in your code.
[19:57] <alecu> I hope you follow the examples and start using DBus to take control of all the apps in your desktop.
[19:58] <alecu> Let's do a bit of Q/A if we have a bit more time.
[19:58] <alecu> And don't hesitate to ask me more questions by mail if you have any problems when working with DBus.
[20:00] <alecu> and please let me know what you ended up doing with DBus! :-)
[20:01] <ClassBot> chadadavis asked: so, when you setup a signal for others to subscribe to, you're responsible for sending them? Can you chain signals, with intermediate changes, to provide variations of existing signals from other services?
[20:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[20:02] <JoseExposito> Hello everyone!
[20:02] <JoseExposito> Thank you very much for joining in this session
[20:03] <JoseExposito> I'm José Expósito and I'm the developer of Touchégg (https://code.google.com/p/touchegg/)
[20:03] <JoseExposito> I'm an independent developper that tries to add more multitouch capabilities to Ubuntu/Linux desktops
[20:03] <JoseExposito> and I'll try to explain what is Touchégg, how it works
[20:04] <JoseExposito> how you can add multitouch support to your computer
[20:04] <JoseExposito> and what technologies it uses.
[20:05] <JoseExposito> And of course I will leave at the final of the session a bit of time for questions.
[20:05] <JoseExposito> Ok, there we go :)
[20:05] <JoseExposito>  
[20:05] <JoseExposito> [+] Introduction to Touchégg: what is it and features
[20:05] <JoseExposito>  
[20:06] <JoseExposito> If you have a touch screen or a trackpad with multitouch capabilities
[20:06] <JoseExposito> probably you know the options that this devices offers in others platforms
[20:06] <JoseExposito> like MacOS or Windows
[20:07] <JoseExposito> but we are Ubuntu/Linux users, we can't use this devices?
[20:07] <JoseExposito> Yes, we can use the maximum capabilities of this kind of devices with Touchégg
[20:07] <JoseExposito> and of course thanks to the work of the uTouch guys.
[20:07] <JoseExposito> So, what is Touchégg?
[20:08] <JoseExposito> Touchégg is a program that offer just that
[20:08] <JoseExposito> the option to squeeze your trackpad or your touch screen capabilities.
[20:09] <JoseExposito> You can think in your touch screen or trackpad like
[20:09] <JoseExposito> a device that allows you to make a number of predefined gestures
[20:09] <JoseExposito> for example drag two fingers, pinch with five fingers or tap with four finger.
[20:10] <JoseExposito> Normally, making this gestures, one expects to see that the computer reacts to them and takes some action
[20:10] <JoseExposito> for example, if you drag two fingers over a PDF,
[20:11] <JoseExposito> you expect that the text begin to scroll or if you pinch three fingers over a window,
[20:12] <JoseExposito> you expect that the windows become to resize.
[20:13] <JoseExposito> Touchégg makes exactly this, is responsible of recognize this multitouch gestures
[20:13] <JoseExposito> and make a configurable action.
[20:14] <JoseExposito> In adition, Touchégg has a GUI (graphical user interface)
[20:14] <JoseExposito> that allow you to configure this gestures and action in a very simple way
[20:15] <JoseExposito> you can see here an screenshot:
[20:15] <JoseExposito> https://lh3.googleusercontent.com/_ReRtolbPWnI/TXpw1FD8jAI/AAAAAAAAAGs/g2d7SUaCPow/touchegg-gui-kde1.png
[20:16] <JoseExposito> Ok, but what gestures it support?
[20:21] <JoseExposito> These gestures can be divided in four big families:
[20:21] <JoseExposito> Tap: A tap gesture is, at this name suggests, a “click” over your trackpad with one to five fingers.
[20:21] <JoseExposito> Drag: Again the name is self-descriptive
[20:22] <JoseExposito> to make this gesture you only need to move two
[20:22] <JoseExposito> to five fingers over your trackpad.
[20:22] <JoseExposito> In addition this gesture allow to define directions,
[20:22] <JoseExposito> ie drag three fingers up, for example to maximize a window
[20:22] <JoseExposito> or drag three fingers down, for example to minimize a window.
[20:22] <JoseExposito> Pinch: Pinch is... a pinch!
[20:23] <JoseExposito> You just only have to imagine the tipical gesture
[20:23] <JoseExposito> that you can make in you smartphone to zoom the window...
[20:23] <JoseExposito> If you have one, my phone still have keys ;)
[20:23] <JoseExposito> In the future this gesture will allow directions (in and out)
[20:23] <JoseExposito> like the drag gesture
[20:24] <JoseExposito> for example to integrate Touchégg with your favorite photo viewer
[20:24] <JoseExposito> to zoom in or zoom out your photos.
[20:24] <JoseExposito> Tap&hold: This is a composite gesture with a tap and a drag
[20:24] <JoseExposito> I think that everyone has used it for example to select text
[20:24] <JoseExposito> but of course Touchégg allows to personalize this gesture with any action and use it with up to five fingers.
[20:25] <JoseExposito> In the future, I hope that when Natty will be ready, Touchégg will support more gestures, such as “Rotate” or “Double Tap”.
[20:25] <JoseExposito> And what about the actions?
[20:25] <JoseExposito> Touchégg allow you to make 14 differents actions
[20:25] <JoseExposito> that you can be associe to the gestures
[20:26] <JoseExposito> This is the full list:
[20:26] <JoseExposito> MOUSE_CLICK – This action allows you to emulate the mouse
[20:26] <JoseExposito> Tipically are assigned to a one, two and three fingers tap to make left, right and middle mouse click respectively
[20:27] <JoseExposito> but of course you can assign this action to any gesture
[20:27] <JoseExposito> VERTICAL_SCROLL and HORIZONTAL_SCROLL – As the name suggest
[20:27] <JoseExposito> these actions allows you to make a scroll, like with your mouse wheel. Tipically asigned to the two fingers drag gesture
[20:28] <JoseExposito> MINIMIZE_WINDOW – To minimize the window under cursor.
[20:28] <JoseExposito> MAXIMIZE_RESTORE_WINDOW – To maximize the window under the cursor or, if is already maximized, to restore it.
[20:28] <JoseExposito> CLOSE_WINDOW – To close the window under the cursor.
[20:29] <JoseExposito> MOVE_WINDOW – Allows you to move a window across the screen.
[20:29] <JoseExposito> RESIZE_WINDOW – To change the size of the window under the cursor, should be used with a pinch gesture.
[20:29] <JoseExposito> SHOW_DESKTOP – In the first execution shows the desktop, in the second execution restores all windows.
[20:30] <JoseExposito> CHANGE_DESKTOP and CHANGE_VIEWPORT – These actions allows you to change between virtual desktops
[20:30] <JoseExposito> the difference is that some window managers, like Compiz uses by default “viewports” and other like KWin uses “virtual desktops”
[20:30] <JoseExposito> SEND_KEYS – Probably one of the most versatile actions
[20:31] <JoseExposito> allows you to assign a shortcut to a gesture for example to use Compiz effects or any specifies application shortcut.
[20:31] <JoseExposito> RUN_COMMAND – Another of the most versatile actions
[20:31] <JoseExposito> This actions allows you to run a command making a gesture, not only useful to run applications, using dbus or custom scrips this action can be really useful.
[20:32] <JoseExposito> DRAG_AND_DROP – Allows you to emulate the classical one finger tap hold gesture
[20:32] <JoseExposito> for example to select text but also with the mouse right or middle button.
[20:33] <JoseExposito> With this combination of gestures and actions
[20:33] <JoseExposito> you can get all the capabilities of your trackpad
[20:33] <JoseExposito> with the more classical and basic gestures
[20:33] <JoseExposito> like make a right buttons click tapping with two fingers
[20:33] <JoseExposito> or other more advanced like resize a window pinching with three fingers,
[20:34] <JoseExposito> use the “Exposse” Compiz effect dragging four fingers up
[20:34] <JoseExposito> move a windows making a tap&hold gesture with two fingers
[20:34] <JoseExposito> or zooming your photos making a double tap with five fingers...
[20:35] <JoseExposito> And make this is very easy, you only need to select the gesture and their associated action in the Touchégg-GUI.
[20:35] <JoseExposito> I recomend you to try Touchégg, especially in Natty
[20:35] <JoseExposito> where the uTouch team guys have done an excellent job with the multitouch support
[20:35] <JoseExposito> but if you are fearful, you can see Touchégg in action in this video:
[20:35] <JoseExposito> http://www.youtube.com/watch?v=1Ek4QaFQ1qo
[20:36] <JoseExposito> Common, go to see the video!
[20:37] <JoseExposito> Ok, and this is all?
[20:37] <JoseExposito> No :P
[20:37] <JoseExposito> In my humble opinion, the multitouch interface is the future
[20:38] <JoseExposito> but for the moment not all applications have support for this gestures
[20:38] <JoseExposito> This suppose a problem, imagine that you want to zoom your photos making a two fingers pinch gesture
[20:38] <JoseExposito> but in adition you want to zoom a web page making also a two fingers pinch
[20:39] <JoseExposito> Well, in this moment probably you think
[20:39] <JoseExposito> no problem, I can go to the Touchégg-GUI and assign the shorcut to this gesture
[20:39] <JoseExposito> but...
[20:39] <JoseExposito> OMG, the shorcut is different in your photo viewer and in your web explorer!
[20:40] <JoseExposito> For this reason Touchégg incorporates a new feature in the next version
[20:40] <JoseExposito> a new option that allow you to assing diferent actions for different applications
[20:40] <JoseExposito> Thus now you can assing a different shortcut to the two fingers pinch gesture
[20:41] <JoseExposito> in your photo viewer and in your web browser
[20:41] <JoseExposito> With this new option, Touchégg lets you to add a multitouch layer easyly in your desktop.
[20:41] <JoseExposito> And basically this is Touchégg and these are their options
[20:41] <JoseExposito> In conclusion, the main idea is that you have global gestures
[20:41] <JoseExposito> application specific gestures
[20:42] <JoseExposito>  and actions that should be executed with these gestures
[20:42] <JoseExposito> and Touchégg brings you the option to manage all with a simple and intuitive graphical user interface.
[20:42] <JoseExposito>  
[20:42] <JoseExposito> [+] Technologies used to develop Touchégg: uTouch-GEIS and Qt
[20:42] <JoseExposito>  
[20:42] <JoseExposito> For now we have talked about what is Touchégg and what it makes but no about how it makes that
[20:43] <JoseExposito> This part is more technical that the previous part and probably will be more interesting for developers
[20:43] <JoseExposito> anyway I'll try to make it easy to understand and funny as possible for the non-developers attendees
[20:43] <JoseExposito> Touchégg is developed in C++ and it uses two mainly tecnologies: Qt and uTouch-GEIS.
[20:43] <JoseExposito> First I'm going to talk briefly about Qt
[20:44] <JoseExposito> becouse I think that is a very popular workspace and many people will know it
[20:44] <JoseExposito> Many people thinks that Qt is only a framework to build graphical interfaces
[20:44] <JoseExposito> and of course, Touchégg-GUI uses Qt to make one, but Qt is more than this
[20:45] <JoseExposito> Qt have many classes that facilitates programming, like work with XML, threads, sockets, dbus, etc, etc
[20:46] <JoseExposito> And the better is that is multiplatform and binaries generated using this technology are small and fast!
[20:47] <JoseExposito> Talk about the advantages of Qt probably need other complete conference, in fact this year Qt is the issue of many conferences, so I'm going to talk about uTouch-GEIS.
[20:47] <JoseExposito> In Ubuntu 10.10 Canonical made an important contribution to the open source comunity with uTouch
[20:47] <JoseExposito> a complete framework composed by many differents tools to bringing Linux multitouch support.
[20:48] <JoseExposito> Touchégg uses uTouch-GEIS, that is an API that makes very easy to developers get the produced gestures in the multitouch devices.
[20:48] <JoseExposito> Now in Ubuntu 11.04 Natty, the new multitouch support is awesome
[20:48] <JoseExposito> the uTouch-team has done an excellent job. I can't talk about the technical part of uTouch-GEIS
[20:48] <JoseExposito> anyway you can see an excellent explanation about it here:
[20:49] <JoseExposito> https://wiki.ubuntu.com/MeetingLogs/appdevweek1104/Multitouch
[20:49] <JoseExposito> For developers uTouch-GEIS bring two differents interfaces, one simplified and other more complex
[20:49] <JoseExposito> For the objetives of Touchégg, the simpified interface is more than sufficient, you can see a little example code here:
[20:49] <JoseExposito> https://bugs.launchpad.net/utouch-geis/+bug/754135/+attachment/2004778/+files/test.cpp
[20:49] <JoseExposito> And ofcourse the Touchégg source code:
[20:50] <JoseExposito> https://code.google.com/p/touchegg/source/browse/#svn%2Ftouchegg%2Fsrc%2Ftouchegg
[20:51] <JoseExposito> I think that for a C or C++ developer beging to use uTouch is really easy and in adition the documentation is excellent:
[20:51] <JoseExposito> http://people.canonical.com/~stephenwebb/geis-v2-api/
[20:51] <ClassBot> There are 10 minutes remaining in the current session.
[20:52] <JoseExposito> And well, this is all, you can make now questions
[20:52] <JoseExposito> and remember that you can contact with me to make more questions, report a bug or request new features for Touchégg here:
[20:52] <JoseExposito> https://code.google.com/p/touchegg/issues/list
[20:56] <ClassBot> There are 5 minutes remaining in the current session.
[20:58] <ClassBot> alecu asked: what API are you using to get the multi touch events?
[20:59] <ClassBot> alecu asked: I'm developing a game that will use multitouch directly, so will it be possible to disable TouchEgg events for one specific window?
[21:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[21:02] <kamstrup> Hi all!
[21:02] <kamstrup> So I guess I am up now
[21:02] <kamstrup> My name is Mikkel Kamstrup Erlandsen and i work for Canonical on the DX team
[21:02] <kamstrup> In my spare time I also dabble with software, namely Zeitgeist and search engines
[21:03] <kamstrup> On the DX team I am working on all the backend and infrastructure stuff
[21:03] <kamstrup> so not so much all the fancy graphics you see in Unity
[21:03] <kamstrup> but all that goes on beneath it :-)
[21:03] <kamstrup> In particular relevant for this session libunity
[21:04] <kamstrup> libunity is a library with the purpose of instrumenting and integrating with Unity
[21:04] <kamstrup> For the Natty cycle you'll be able to integrate with the Launcher and the Places/Lenses
[21:05] <kamstrup> (btw for this session I'll call it Places - but in the Oneriric cycle we'll officially change to Lenses)
[21:05] <kamstrup> (it's just that "places" is in my muscle memory right now :-))
[21:05] <kamstrup> One big caveat emptor before we proceed too far
[21:06] <kamstrup> libunity does not currently have API or ABI stability guarantees
[21:06] <kamstrup> we will work on that - promised - but we also want to ensure that the API is really really nice before we freeze it
[21:06] <kamstrup> and in fact
[21:06] <kamstrup> I can already guarantee that there will be slight changes when we begin the Oneiric cycle
[21:07] <kamstrup> but that said
[21:07] <kamstrup> You can already take libunity for a spin and do some pretty impressive stuff with it
[21:07] <kamstrup> fx. both the Apps and Files places are implemented with libunity
[21:07] <kamstrup> there's no "priviledged" Unity API for those two buggers
[21:08] <kamstrup> anyone here will be able to do exactly what they do
[21:08] <kamstrup> Before we start talking about the places let's talk about the Launcher integration
[21:08] <kamstrup> The Launcher integration is a lot simpler than the places
[21:09] <kamstrup> So enough with the intro talk
[21:09] <kamstrup> --------------------
[21:09] <kamstrup> The Unity Launcher
[21:09] <kamstrup> The simplest way you can integrate with the launcher is via what is called "static quicklists"
[21:09] <kamstrup> https://wiki.ubuntu.com/Unity/LauncherAPI#Static%20Quicklist%20entries
[21:10] <kamstrup> If you follow that link you'll see a snippet from a normal .desktop file
[21:10] <kamstrup> If you take a normal .desktop file and add [Foo Shortcut Group] entries to it like shown
[21:10] <kamstrup> you can add quicklist right there
[21:11] <kamstrup> Look at your own /usr/share/applications/evolution.desktop for a live example
[21:12] <kamstrup> What static quicklist elements can basically do is launch an executable
[21:12] <kamstrup> so very simple
[21:12] <kamstrup> no programming required
[21:12] <kamstrup> If you want to get a bit more power
[21:12] <kamstrup> you need to use libunity
[21:13] <kamstrup> More specifically the LauncherEntry API
[21:13] <kamstrup> For the sake of the examples we'll use Python examples today, but you can also code in Vala, C
[21:13] <kamstrup> (or C++ if you manually write the C calls out)
[21:14] <kamstrup> You'll see the API here http://developer.ubuntu.com/api/ubuntu-11.04/GIR/python/Unity-3.0.html#Unity.LauncherEntry
[21:14] <kamstrup> it may deserve mention that we are starting to push up Python docs for the libs generated via GObject Introspection to http://developer.ubuntu.com/api/
[21:14] <kamstrup> Anyway
[21:15] <kamstrup> Looking at the LauncherEntry docs you'll see that it only has static constructors - not conventional constructors
[21:15] <kamstrup> that's because you always get a "singleton" back for the particular app
[21:15] <kamstrup> Let me find an example
[21:16] <kamstrup> Here http://bazaar.launchpad.net/~unity-team/libunity/trunk/view/head:/examples/launcher.py
[21:16] <kamstrup> You can set 3 main properties on the launcher entry
[21:16] <kamstrup> A "count" that will be displayed as a number on the top part of the tile
[21:17] <kamstrup> you may have seen this on apps like Evolution displaying the number of unread mails this way
[21:17] <kamstrup> Then you can add a progress bar
[21:17] <kamstrup> the values for progress must be between 0 and 1
[21:17] <kamstrup> (and it's a float)
[21:17] <kamstrup> You can also set the urgency hint
[21:18] <kamstrup> Some may know that an "urgency hint" is something you normally have on X11 windows
[21:18] <kamstrup> it makes the WM flash the window icon
[21:18] <kamstrup> the difference here is that the libunity urgency doesn't require a window on the screen in order to mark an app as requiring attention
[21:19] <kamstrup> this can be useful for background processes like Ubuntu One or others that need to draw your attention to their icon when they don't have a window on screen somewhere
[21:20] <kamstrup> The last part of the LauncherEntry API is that you can set a "dynamic quicklist"
[21:20] <kamstrup> The dynamic quicklists differ from the static ones in that you can build and update them programmatically at runtime
[21:21] <kamstrup> You simply have access to a libdbusmenu DbusmenuMenuItem instance that you can populate how you like
[21:21] <kamstrup> ok
[21:21] <kamstrup> any questions on the laucnher api before we move on?
[21:22] <kamstrup> ------------
[21:22] <kamstrup> so now to Places
[21:22] <kamstrup> As said before the situation here is slightly regretable
[21:22] <kamstrup> It's known both as Lenses and Places in Natty
[21:23] <kamstrup> For Oneiric we'll change to Lenses only
[21:23] <kamstrup> (also in the all the public APIs)
[21:23] <kamstrup> but for now let me call them Places
[21:23] <kamstrup> Places run outside the core Unity process
[21:24] <kamstrup> Think of them very much like remote database that provides data for Unity to render
[21:24] <kamstrup> if you've worked with modern web development frameworks or MVC in UIs think that the place provides the *model* and Unity is a generic View
[21:25] <kamstrup> Of course we have the standard Apps and Files places
[21:25] <kamstrup> they are not very good beginner examples unfortunately
[21:25] <kamstrup> but there are a few simple examples to start from that lots of ppl have found instructive
[21:25] <kamstrup> If we stick to the Python example again
[21:26] <kamstrup> you can check it out from lp:~unity-team/unity-place-sample/unity-place-python
[21:26] <kamstrup> or for now just browse it online at http://bazaar.launchpad.net/~unity-team/unity-place-sample/unity-place-python/files
[21:27] <kamstrup> First look at python.place
[21:27] <kamstrup> All places register themselves to unity via a .place file
[21:27] <kamstrup> installed under /usr/share/unity/places
[21:27] <kamstrup> in a .place file you specify some contact info for Unity to find you on dbus
[21:28] <kamstrup> Then each place has one or more PlaceEntries
[21:28] <kamstrup> A placeentry is prettymuch what maps to an icon in the launcher
[21:28] <kamstrup> You'll probably have the Apps and Files entries in your launcher at the bottom
[21:29] <kamstrup> For each entry you want to expose from your place's process you need a [Entry:Foo] line in the .place file
[21:29] <kamstrup> The only place that actually has more than one place entry is the Apps place
[21:30] <kamstrup> although the second one is hidden
[21:30] <kamstrup> Try looking at /usr/share/unity/places/applications.place
[21:30] <kamstrup> you'll see that [Entry:Runner] has ShowEntry=false and ShowGlobal=false
[21:31] <kamstrup> First ShowEntry=false tells unity to not put a tile in the launcher bar for this place entry
[21:31] <kamstrup> the ShowGlobal=false clause tells Unity to not include this entry's results when searching from the Dash
[21:31] <kamstrup> aka home screen
[21:31] <kamstrup> (the one you get when you hit <super>)
[21:32] <kamstrup> There is in fact a spec for these .place files
[21:32] <kamstrup> Check https://wiki.ubuntu.com/Unity/Lenses#Registration
[21:32] <kamstrup> You'll also note that you can define a keyboard shortcut for you place
[21:33] <kamstrup> And now we're talking about this
[21:33] <kamstrup> A general best-practice is to *not* include your search results in the Dash
[21:33] <kamstrup> that is please set ShowGlobal=false
[21:34] <kamstrup> When I write my code I am as excited as anyone to get people using it
[21:34] <kamstrup> but people really want a fast Dash
[21:34] <kamstrup> and if we have Dash searches laucnhing off 3 http requests, 5 disk searches, and whatnot for each letter typed...
[21:34] <kamstrup> so if you want to integrate with the Dash results make sure your results are:
[21:35] <kamstrup> 1) almost always relevant
[21:35] <kamstrup> 2) Super snappy
[21:35] <kamstrup> 3) Doesn't use to many resources to compute
[21:35] <kamstrup> and 1) is probably the key point
[21:35] <kamstrup> So most places would just have their tile in the launcher and a keyboard shortcut
[21:36] <kamstrup> Ok back to the code
[21:36] <kamstrup> In the .place file you specify the dbus contact details for your place daemon
[21:36] <kamstrup> this means that Unity will start your daemon via dbus activation
[21:37] <kamstrup> no need to start it yourself on login or anything
[21:37] <kamstrup> this way unity has a chance of not starting all daemons at once when you log in
[21:37] <kamstrup> which would run the risk of hogging your disk
[21:38] <kamstrup> ok
[21:38] <kamstrup> now look at http://bazaar.launchpad.net/~unity-team/unity-place-sample/unity-place-python/view/head:/unity-place-python.py
[21:38] <kamstrup> This is the code for the sample place daemon
[21:38] <kamstrup> There are 3 concepts you need to know about when writing a place dameon
[21:38] <kamstrup> that is 1) results 2) groups 3) sections
[21:39] <kamstrup> each of these three have a Dee.Model associated with them
[21:39] <kamstrup> Dee.Model is implement by a library called libdee which we use for almost all of the data sharing behind Unity
[21:39] <kamstrup> Dee.Model is like a table that is shared between multiple processes
[21:40] <kamstrup> if any one changes, adds, or removes from the model all the other processes watching that model will be notified of what's changed
[21:40] <kamstrup> pretty powerful stuff
[21:40] <kamstrup> this allows us to do a kind of "distributed MVC"
[21:41] <kamstrup> so in one we have the place daemon that updates the results Dee.Model and Unity is watching that same model, updating the View whenever it changes
[21:41] <kamstrup> So obviously the results_model contains all the search results
[21:41] <kamstrup> then we have a sections_model
[21:42] <kamstrup> the sections partition the results into disjoint logical components
[21:42] <kamstrup> A sections should represent a "browsable" subset of the result space
[21:42] <kamstrup> If you consider the space of all apps then the sections could be Video, Audio, Games, Office
[21:42] <kamstrup> etc
[21:43] <kamstrup> The sections contribute the elements of the dropdown embedded in the search bar
[21:43] <kamstrup> you can also access the sections of a place via the right-click context menu on a place entry in the laucncher
[21:43] <kamstrup> then there a groups
[21:44] <kamstrup> the groups partition the visible result set into meaning subgroups
[21:44] <kamstrup> If you are watching all hits from a file search the groups could be Today, Yesterdat, Last Week, Last Month, ... etc
[21:45] <kamstrup> the groups_model and results_model both have a _global_ counterparts
[21:46] <kamstrup> the global models are the ones used for searching from the dash
[21:46] <kamstrup> (so you normally don't need those)
[21:46] <kamstrup> btw
[21:46] <kamstrup> the API docs for Dee.Model are here http://developer.ubuntu.com/api/ubuntu-11.04/GIR/python/Dee-0.5.html#Dee.Model
[21:46] <kamstrup> The API docs for Dee are not fully true though
[21:47] <kamstrup> it has been augmented with some Python sweetness
[21:48] <kamstrup> There is currenlty no easy way to document this Python magic, but you can find a demo of the Python magic for Dee.Model here http://bazaar.launchpad.net/~unity-team/dee/trunk/view/head:/examples/pythontricks.py
[21:49] <kamstrup> You can also find the docs for what exactly the columns are in all the different models on https://wiki.ubuntu.com/Unity/Lenses#Results%20Model
[21:49] <kamstrup> One last thing I want to mention is "Activation"
[21:50] <kamstrup> So places require special callbacks when activating some special results
[21:50] <kamstrup> Fx.
[21:50] <kamstrup> the apps place returns Apps Available for Download that open in the Software Center when you click the,m
[21:50] <kamstrup> this is achieved via the Activation API
[21:51] <kamstrup> you basically register a handler for a regex matching URIs or mimetypes
[21:51] <ClassBot> There are 10 minutes remaining in the current session.
[21:51] <kamstrup> then when unity tries to laucnh a it it looks for any places registered for launchoing that hit
[21:51] <kamstrup> and does a Dbus callback to the place daemon giving it the URI to activate
[21:52] <kamstrup> the place daemon then responds whether Unity should hide the Dash as a response or if the Dash should still be shown
[21:52] <kamstrup> in case for Apps Availabale for Download we ask Unity to hide the dash
[21:52] <kamstrup> (so we can load S-C)
[21:53] <kamstrup> but if we fx. wanted to implemen
[21:53] <kamstrup> implement
[21:53] <kamstrup> a file browser fx
[21:53] <kamstrup> then we could ask unity to keep the dash on screen, and then just clear our results_model and repopulate it with the contents of the clicked directory
[21:54] <kamstrup> I guess I'll leave the rest for your own exploration
[21:54] <kamstrup> So if anyone has questions don't hold back
[21:55] <kamstrup> if that's not the case then let me take 2 minutes to talk about "renderers"
[21:56] <kamstrup> if you browse https://wiki.ubuntu.com/Unity/Lenses#Renderers
[21:56] <kamstrup> you'll see that we have a concept called renderers which you can specify in various places in the API
[21:56] <ClassBot> There are 5 minutes remaining in the current session.
[21:57] <ClassBot> tronda asked: How much focus is the Python based API getting?
[21:57] <kamstrup> Almost as much as the C/Vala API
[21:58] <kamstrup> we really want it to be a 1st class experience
[21:58] <kamstrup> and honestly i almost think that the Python API is better than the Vala/C api right now :-O)
[21:58] <ClassBot> tronda asked: Any plans to get browser to work with the libunity for web applications?
[21:59] <kamstrup> not short term
[21:59] <kamstrup> there are some far out plans, but nothing to hold your breath for :-)
[21:59] <ClassBot> tronda asked: If working with a web service which is potentially slow - would one use Tracker/Zeitgest to index content. Any help from Unity to make this simpler?
[22:00] <kamstrup> Because the place daemon is another process than Unity it's not super critical if web services are slow
[22:00] <kamstrup> so I'd say "don't worry in most cases"
[22:01] <ClassBot> alecu asked: when a lens adds item, I see that it can add a url to get the item picture from it, like the books lens does with book covers. Will this be standard?
[22:01] <kamstrup> yes, yes it will
[22:01] <kamstrup> i believe that you can simply insert a URL as icon and Unity will try and load it
[22:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html following the conclusion of the session.
[22:02] <jelmer> hello
[22:03] <jelmer> I'll be talking to you today about Bazaar, the version control system.
[22:04] <jelmer> My name is Jelmer Vernooij and I'm one of the Bazaar hackers. I'll quickly go over what Bazaar is and some of the basics before briefly discussing some of the more advanced features that I think might be interesting to app developers.
[22:04] <jelmer> Please ask questions, and if there are other features you're interested in and would like me to cover, please mention so. I'm more than happy to cover other Bazaar-related topics instead.
[22:05] <jelmer> Bazaar is version control system, which can track the changes of your source code over time. You might be familiar with other version control systems such Subversion, CVS, Perforce or Visual Sourcesafe.
[22:06] <jelmer> Like many current generation version control systems, such as Git or Mercurial, Bazaar is distributed. This means that somebody who checks out the source code gets a full copy of the history on their local machine rather than having a central location with the full history and requiring all changes to happen on that central server.
[22:07] <jelmer> Every clone of your source history will have a hidden .bzr/ subdirectory which contains Bazaar metadata. You can use the bzr command to inspect and add to the history of your tree.
[22:07] <jelmer> To version a tree using Bazaar, run "bzr init" in the root followed by "bzr add" to add the files you would like Bazaar to track. When you're happy, run "bzr commit" to store the first revision of your tree.
[22:08] <jelmer> Bazaar will ask you for a description of your changes. Later on, when you've changed files you can run "bzr commit" again to store those changes as a new revision.
[22:08] <jelmer> This creates a series of revisions, named a branch.
[22:08] <jelmer> Let's try this with a simple hello world program:
[22:08] <jelmer> $ mkdir hello
[22:08] <jelmer> $ cd hello
[22:08] <jelmer> $ bzr init
[22:09] <jelmer> Bazaar should now tell you that it's created a branch and what file format it used.
[22:09] <jelmer> After you've done this you should see a .bzr/ meta directory if you run "ls -a".
[22:10] <jelmer> Now, create a file and tell Bazaar to track its history. I'm creating hello.sh which simply prints "Hello, World" on standard out.
[22:10] <jelmer> $ bzr add hello.sh
[22:11] <jelmer> You can now use "bzr commit" to store this as your first revision.
[22:11] <jelmer> are there any questions so far ? Am going too fast, should I skip the basics?
[22:12] <jelmer> Sorry, s/Am/Am I/
[22:13] <jelmer> $ bzr commit
[22:13] <jelmer> This will launch your editor and allow you to specify a message describing your changes. Since this is our original commit, I usually just type "Initial commit"
[22:13] <jelmer> To look at the history of your source code later, you can use various bzr subcommands. Mostly commonly used are "bzr log", "bzr diff", "bzr cat" and the graphical "bzr qlog" (a QT revision browser) and "bzr viz" (a GTK+ revision browser).
[22:15] <jelmer> If you change your file again you can run "bzr commit" to store your new changes.
[22:15] <jelmer> "bzr log" should show you two revisions at this point.
[22:15] <jelmer> To share code, you can push your branch somewhere using the "bzr push" command, pull in new changes from somebody else using the "bzr pull" command or create a clone of a branch found elsewhere using "bzr branch".
[22:16] <jelmer> Bazaar allows you to push over the HTTP, SSH, SFTP and FTP transports as well as to local paths.
[22:19] <jelmer> "bzr push" and "bzr pull" only allow you to add new revisions to existing history. If two branches have different changes, then you can use "bzr merge" to merge the two branches. If you merge somebody else's branch then their changes will be merged into your local tree. When you're happy with the way the trees were merged, you can run "bzr commit" to create a new revision that joins the changes.
[22:19] <jelmer> Bazaar integrates with various other Ubuntu related tools. For example, Launchpad uses Bazaar as its version control system. You can push branches to Launchpad so others can access them.
[22:19] <jelmer> Launchpad can also import branches from other version control systems like Git, Subversion, Mercurial or CVS for you. Launchpad will automatically add links on a branch page for bugs that have been marked as fixed by that branch.  You can use a shorthand ("lp:") to address Launchpad from within Bazaar.
[22:20] <jelmer> Let's try to push the branch we created earlier to Launchpad. Assuming you're already logged in to Launchpad you can run "bzr push lp:~YOURNAME/+junk/hello".
[22:21] <jelmer> Where YOURNAME is your Launchpad user name. If you get an error about logging in, you need to tell Bazaar about your Launchpad id by running "bzr lp-login".
[22:21] <jelmer> This will create a branch named hello in your area of Launchpad that's not tied to a particular project. Use "bzr lp-open" to see Launchpad's page for your newly created branch.
[22:22] <jelmer> QUESTION: So, you generally don't push from your working directory to someone else's, but rather to a common directory that you use for accumulating and tracking versions?
[22:24] <jelmer> There is no right answer to this, but usually you push to a central location, where all developers pull in new upstream changes from that central location and their branches eventually get merged into the upstream location again.
[22:24] <jelmer> For more information on the possible workflows, see this wiki page: http://wiki.bazaar.canonical.com/Workflows
[22:25] <jelmer> What works best for you depends on the goals of your project, the number of developers, etc.
[22:26] <jelmer> For example, in Bazaar we have a robot that is the only one with write access to our main branch. When a developer makes a change they push their branch to Launchpad, send an email to the robot and the robot will merge their branch, run the testsuite and only push to the main branch if all tests passed.
[22:26] <jelmer> QUESTION: what does the --use-existing mean? when you bzr push --use-existing lp:~YOURNAME/=junk
[22:27] <jelmer> --use-existing means that Bazaar will push to a location, even if that location is a directory with existing files. You shouldn't have to use it for Launchpad
[22:29] <jelmer> To clone an existing branch on Launchpad, you can use "bzr branch" as I mentioned earlier. For example, you can make a clone of pydoctor project by running "bzr branch lp:pydoctor pydoctor".
[22:30] <jelmer> There are several useful plugins available for Bazaar. If you're a web developer, you might want to have a look at bzr-upload. If you are doing Ubuntu or Debian packaging you might be interested in the bzr-builddeb plugin.
[22:31] <jelmer> "bzr plugins" will print a list of plugins you currently have installed.
[22:32] <jelmer> For a full list of the available plugins, have a look at this page: http://wiki.bazaar.canonical.com/BzrPlugins
[22:32] <jelmer> The most commonly used ones are also packaged separately in Ubuntu.
[22:33] <jelmer> You might in particular be interested in the bzr-gtk or qbzr plugins, which provide a graphical interface on top of Bazaar.
[22:34] <jelmer> ("bzr-gtk" and "qbzr" are also the names of their respective packages in Ubuntu)
[22:35] <jelmer> E.g. qbzr provides the "bzr qlog" command I mentioned earlier which allows you to browse history. Another useful command is "bzr qannotate" which will show you for each line in a file in which revision it was last modified, as well as the author of that revision and the message associated with that revision.
[22:38] <jelmer> As I mentioned earlier, Launchpad can import revision history from other version control systems. It has upstream imports of a lot of upstream projects.
[22:38] <jelmer> For example, lp:bzr is the upstream Bazaar source code, and lp:samba is the upstream Samba source code (Samba's source code is maintained in Git).
[22:39] <jelmer> Launchpad also has branches for all source packages in Ubuntu. If you have a recent version of Bazaar installed, you can check out these branches by using "bzr branch ubuntu:PACKAGENAME"
[22:40] <jelmer> One of the latest cool features of Launchpad are source recipes. Recipes are simple scripts of a couple of lines that can combine branches and build Debian source packages from them.
[22:41] <jelmer> Launchpad can regularly (usually once a day, if one of the branches changed) build recipes for you. This is really useful if you want to regularly build Ubuntu packages of revisions of your application. It allows users to easily run the latest revision of your application.
[22:42] <jelmer> The recipes are built at most once a day, when one of the branches in the recipe changes.
[22:42] <jelmer> The resulting packages end up in a PPA.
[22:42] <jelmer> Let's have a look at a recipe for the pydoctor tool - https://code.launchpad.net/~jelmer/+recipe/pydoctor-daily
[22:43] <jelmer> At the bottom of the page you can see that this recipe combines two branches:
[22:43] <jelmer> lp:pydoctor, which contains the upstream source code and  lp:~jelmer/pydoctor/unstable which contains packaging metadata.
[22:44] <jelmer> This recipe is built daily without any intervention from anybody other than new revisions being pushed to Launchpad. As you can see, the last time it was built was on March 21, when Michael Hudson (the developer of pydoctor) made a change to the upstream branch. This caused a new package to be built into my PPA.
[22:45] <jelmer> Packaging is outside of the scope of this session, as are recipes, but if you're interested I'd recommend watching Matthew Revell's screencast that explains recipes in more detail.
[22:45] <jelmer> http://blog.launchpad.net/cool-new-stuff/source-package-recipes
[22:46] <jelmer> Speaking about documentation... Bazaar has a lot of good user documentation, most of which can be found on our web site: http://doc.bazaar.canonical.com/bzr.dev/en/
[22:46] <jelmer> Is there anything else you would like me to cover?
[22:47] <jelmer> If you're already using Bazaar, is there anything that you find problematic? Perhaps I can give hints to improve your workflow.
[22:48] <jelmer> QUESTION: how would i "bzr push" behind a proxy/firewall?
[22:50] <jelmer> That's a good question. For just pushing over HTTP (which we support too, but which is not supported by Launchpad), you can set the http_proxy environment variable.
[22:51] <ClassBot> There are 10 minutes remaining in the current session.
[22:51] <jelmer> Looking at the docs quickly I can't find any details on using SSH over a proxy.
[22:52] <jelmer> You should be able to use corkscrew, see http://www.omappedia.org/wiki/Using_bzr_and_launchpad_behind_a_proxy for details.
[22:53] <jelmer> Are there any other questions?
[22:56] <jelmer> QUESTION: outside of hosting sites like launchpad, how does one traditionally send a merge request? Is there a way to link repositories? Or do you just simply pull from it and see?
[22:57] <jelmer> You can either just ask the person that you would like to do the merge informally. ("I have fixed bug X and my branch is at location http://..../, please merge"); or you can send them an email that contains the changes ("bzr send --mail-to=their-email-address")
[22:58] <ClassBot> There are 5 minutes remaining in the current session.
[23:00] <jelmer> Only one minute remaining.. thanks for attending. If you have any further questions, don't hesitate to ask in #bzr
[23:01] <ClassBot> Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/13/%23ubuntu-classroom.html