didrocks' blog

MAIS QUE SE PASSE-T-IL CETTE SEMAINE SUR UBUNTU ?

Eh bien, c'est la Global Jam, évènement regroupant toutes les loco-teams d'ubuntu à travers le monde afin de passer un week-end à apprendre et à contribuer au projet Ubuntu. Et Ubuntu-fr en propose deux en France.

Pas besoin d'être technicien/développeur/programmeur/geek/...^[1], l'évènement se veut grand public ! Venez simplement avec votre ordinateur (point très important) et lancez-vous ! Pour cela, plusieurs activités sont proposées :

- une testing jam : jeudi prochain sort la version béta^[2] de karmic koala (la 9.10), prochaine version d'Ubuntu. Nous vous proposons que vous veniez accompagné de cette version gravée sur un CD (la béta sera disponible jeudi normalement et un billet sur le planet vous indiquera où la télécharger). Pas besoin de l'installer, cela se fera lors de la Jam et fait parti des points à tester. :)

- une documentation jam : vous êtes-t-il arrivé de râler auprès d'une page de la documentation d'ubuntu-fr dont la description ne marchait pas, était obsolète ou tout simplement pas assez précise/détaillée ? Devenez alors acteur (pensez que toute la documentation est uniquement maintenue par des bénévoles) ! La documentation jam est là pour que vous ne soyez pas perdu et des directives simples mais précises permettra de défricher ce travail titanesque. Même si vous ne sentez pas de rédiger de nouvelles pages, rien que le fait de corriger des fautes, reformuler de manière plus claire est une contribution tout à fait valable et louable. :)

- une bug jam : Un bug jam consiste à trier des bugs sur Ubuntu. Pas de compétence technique n'est requise, uniquement une maitrise minimale de l'anglais écrit. Après une initiation au tri de bug, présentation de launchpad, inscription des comptes et des différents process de développement d'ubuntu, il sera temps de mettre en pratique de ce que l'on a appris, toujours accompagné de personnes qui sont habituées à cette tâche. Également, si vous étiez venu il y a 6 mois et n'avez pas pu pratiquer, il est temps de venir prendre un petit cours de rattrapage :)

Tout cela aura lieu ce dimanche 4 octobre, à la cité des sciences et de l'industrie, porte de la Villette à Paris, Pour s'y rendre, rien de plus facile^[3]. L'évènement se déroulera au sein du carrefour numérique de la cité, niveau -1. Les horaires: 14h à 18h00.

Si vous êtes sur Toulouse, n'oubliez pas qu'ubuntu-fr organise également une global jam sur place le samedi 3 octobre à partir de 11h30.

N'hésitez plus, et lancez-vous ce week-end !

Informations connexes sur le site d'ubuntu-party.

You have now your amazing and remarkable new Quickly "ubuntu-project" templated project but don't know how to start hacking on it? Here are some tips for you, just there, keep on!

Modifying your ubuntu-project

edit command

Quickly edit is a convenient command to open all of your python files contained in your project in your default editor, ready for editing. Just run:

$ quickly edit

anywhere in your project tree.

It will most likely open them on gedit, apart in case you put other values in EDITOR or SELECTED_EDITOR environment variables. Consequently, if you previously configured your editor with sensible-editor, this one will be chosen^[1].

glade command

This command enables you to open all generated UI files in Glade, so that you can modify your interface. UI files are where your interface is described and Glade is here to give you some handy way of defining it.

$ quickly glade

Note that If you just run Glade from the Applicatons menu it won't work with Quickly. Indeed, what Quickly does is assume that there is one UI file for each Python class for each window type instead of a single big ui file that defines all of the UI for the whole project. This allows each class to derive from window, and most importantly from Dialog. Quickly needs to generate some xml files to tell Glade about these classes and if you just load Glade from the Applications menu, Glade doesn't get to see those UI files and won't load the UI files rather than risk corrupting them.

dialog command

This command helps you to create a new dialog into your project.

$ quickly dialog <dialog_name>

where <dialog_name> is one or more words separated with underscore.

This will create:

1. A subclass of gtk.Dialog called DialogNameDialog in the module DialogNameDialog.py
2. A glade file called DialogNameDialog.ui in the ui/ directory
3. A catalog file called dialog_name_dialog.xml also in the ui/ directory

The default opened file is the main window for your application. You can switch to others under the "Projects" menu.

save command

Ok, you should rather save your project at regular interval, using a revision control system (enabling you to revert back to any point in time, to share with other your code and merge their work into your). Quickly save enabling taking this kind of snapshot of your project:

$ quickly save notes about changes

where "notes about changes" is optional text describing what changes were made since the last save.

It basically commits all changes since the last save to bzr, using a default text if you don't specify one. If you need revert or otherwise use the revision control, use bzr directly.

Note that it does not push changes to any back up location.

Well, that's almost it. You can now really begin to work on your project using all the Quickly goodness. Next subject will be the last one: sharing your finished product and packaging it as easy as pie.

This post will make a little pause in Quickly features reviewing to focus on the template creation. Ever wanted to create your own Quickly template, or to modify slightly the existing ubuntu-project template to make different choices? This part is for you!

If you aren't interested, we will begin the ubuntu-project template description next week, see you there!

Quickly Templates

General stuff

Templates can be written in whatever language you want. They are just a set of commands in a directory, containing commands to copy images, documents and interacting with the user.

Adding a command is quite easy: just drop it into the root template directory and make it executable. Quickly will know by this way that the current file is a command that Quickly Core can launch. Consequently, if you need additional internal commands that can be launched only by your own commands, just create a subdirectory in your template and add it there!

Ready to see how to create a template? Remember than template can be created for everything: generating advanced music list, managing LaTeX files, doing anything without any project (just having all commands that can be launched outside project), etc. You can even create a template with commands written in C to help users design a perl application. :)

Template paths

Quickly will retrieve template in multiple paths. To know which template paths are detected, you can use:

$ quickly --version
Quickly 0.2.3
  Python interpreter: /usr/bin/python 2.5.2
  Python standard library: /usr/lib/python2.5

  Quickly used library: /home/didrocks/Projets/quickly/quickly
  Quickly data path: /home/didrocks/Projets/quickly/data
  Quickly detected template directories:
          /home/didrocks/quickly-templates
          /home/didrocks/Projets/quickly/data/templates/

Copyright 2009 Canonical Ltd.
  #Author 2009 Rick Spencer
  #Author 2009 Didier Roche
https://launchpad.net/quickly

quickly comes with ABSOLUTELY NO WARRANTY. quickly is free software, and
you may use, modify and redistribute it under the terms of the GNU
General Public License version 3 or later.

What is interesting for us are the following lines:

  Quickly detected template directories:
          /home/didrocks/quickly-templates
          /usr/share/quickly/templates/

/usr/share/quickly/data/templates/ is what you should see if you installed Quickly with your package management system. That is the default location for templates.

If you built Quickly yourself and add some options like home= or root= (standard distutils options to specify a different home), your will find them in $your_targeted_directory/templates.

The first path (in my home folder), only appears if you have installed at least one template. This is the place for your personal templates that you don't want to share with user, or just for experimentations.

There are additional checks and possibles paths for people using trunk too, but that's not the point. :)

Create a template from scratch

The best way is to declare your template under ~/quickly-templates by creating a directory into it, like "my-awesome-template".

In it, create scripts/executable files and they will became commands. Easy, isn't it? :) The command name is the command script name without the extension (if present): foo.py becomes foo command, bar.sh will be bar, foobar remain foobar command.

Create a template from another template

But if you are found of an existing Quickly template but you disagree on the choice of a particular technology and want to modify it to apply it to your needs, there is an easy way to achieve this.

You don't have to copy yourself the corresponding templates, but instead, run:

$ quickly quickly <origin template> <new template>

So, for instance:

$ quickly quickly ubuntu-project kubuntu-project

It will create (if it doesn't already exist) ~/quickly-templates, the corresponding subdir and makes some additional checks.

The most important thing is that templates aren't binded: you can modify it independently than the one used at creation time. It's an easy and convenient way to start from existing work.

Little brain breaker

How to complicate it a bit? Oh well, if you really understood the previous parts, you can know how to do that differently:

wherever/you/are $ quickly -t ubuntu-project quickly kubuntu-project

or:

quickly/project/dir $ quickly quickly kubuntu-project

to copy the template associated with current project.

Quickly Core does the hard work for you

If you are using python or not to create your template, Quickly Core does already some part of the work for you. This enables you to relax and know that you are always launched in good conditions. Let's see what's automated.

If you didn't understood part 3, I urge you to read it again, you will need it to follow the next 2 sections :-)

Command launch context

By default, all template commands (contrary to builtin ones) can be launched only in a project "templated" with your project. I guess you remember that there is some additional attributes that you can specify to change that behavior.

All the little black magic is in the commandsconfig file that has to be in the root directory of your template (its presence is not compulsory). Here is the example for the ubuntu-project template

# define parameters for commands, putting them in a list seperated
# by ';'
# if nothing specified, default is to launch command inside a project
# only and not be followed by a template
COMMANDS_LAUNCHED_IN_OR_OUTSIDE_PROJECT = tutorial
COMMANDS_LAUNCHED_OUTSIDE_PROJECT_ONLY = create
COMMANDS_FOLLOWED_BY_COMMAND =

As in every configuration files, you can add comments with #, and use ATTRIBUTE = value format. Quickly Core supports as well list in this format : ATTRIBUTE = command1; command2; .... Of course, we are quite tolerant about the format (extra spaces, comments on the lines, etc.)

So, in that example, I can launch "quickly create ubuntu-project ..." outside a Quickly project only. As it's a template command that can be launched outside a project, it's a project followed by template (read chapter 3 again to see what it implies).
All unlisted commands have the defaults: command not followed by a command nor a template and they can be launched inside a project only.

Also, COMMANDS_FOLLOWED_BY_COMMAND is almost self explanatory. Think about the help builtin command presented in part 3. (Not sure if any other command will need it, but well, all the logic is implemented in a generic way, so, let's get it available if some people need it) :)

Then, Quickly Core will do every checks to ensure that the command is in the good context and has the right parameters to be launched (or to propose this template if not specified for this command, etc.).

Shell completion

Basic one

The good news if you followed the previous section is that you have nothing to add. Shell completion automatically understands if the command should be available or not considering the current context (inside a project or not, a template already provided with the --template option on the command line, etc.) and propose you what you can use.

Same for templates proposal if you are executing a command out of a project. It will as well propose another command if you specified the right attribute. Also, if a command name is in more than one template, it will automatically fetch to show you what is available to the user as previously described in part 4.

Add advanced completion

Ok, but I know, you want more than basic completion for your awesome template. For instance, the license command in the ubuntu-project template display available licenses.

Here, the logic is "logically" outside of Quickly Core as it shouldn't integrate template-specific stuff. So, once the basic completion will give no more solution (that is to say, context is ok, templates are specified, commands too if needed...), it will launched the script with shell-completion as the first argument, and then, what has been specified on the command line.

Let's take an example:

$ quickly -t ubuntu-project licence [Tab]

(Note that -t ubuntu-project is not compulsory if you are in a ubuntu-project "templated" project)

It will launch licence.py of ubuntu-project template project with shell-completion "" parameters.

$ quickly foo bar test [Tab]

It will launch foo script with shell-completion bar test ""

$ quickly foo bar tes[Tab]

However, this latter will launch foo script with shell-completion bar tes. (as last parameter isn't empty, you know on which word tab completion is launched). But you still can show all candidates, like "you, should, test, it" and Quickly shell-completion script will fetch with current parameter (to choose here "test", only candidate which matches "tes").

Ok, but how to tell Quickly that "those results are values that can be used in shell-completion"? Easy, just print it! In the previous case, you can just execute in your code: print "you should test it" (or echo, or printf depending on the chosen language...). a blank space is needed but no order is required (it will be reordered automagically with TabTab)

So, keep in mind that we can launch script with shell-completion parameter each time the user spawn shell completion. Conseuqnetly, design your commands accordingly (see later for a tools to help you with that if you are writing your template in python)

Help to figure out help

The help system use a similar feature. You just have to print the help when Quickly Core call your command with help parameter. Again, a convenient function will be described later for Quickly templates in python.

Command line treatment

Quickly Core is stripping all known options and arguments like templates (when following command like in command followed by templates without the -t option or not in a Quickly project) to have always the same state for the command.

With this, you are assured to have your own parameters to treat, not Quickly specific ones and no context to deal with. Focus on template coding, don't deal with this mess, Quickly Core does it for you :)

Special option that we saw in previous chapter is provided on commodities function for python (see below) or in environment variable. For instance, there will be a staging string in QUICKLY environment variable if the user used the --staging option or exported directly the variable. Same system is used for verbose mode. Quick reminder: multiple values are separated by ":".

Launching from root project directory

You can always consider your command is launched from project root directory, even if the user is in a subsubsubdir (or even deeper in the directory tree hierarchy) of the project. Quickly Core in all its cleverness and goodness guide your script to change their current working directory. :)

The only restriction is for commands that can be launched outside a project and that are actually launched in this context (outside of any project). This is a normal behavior, as they are specifically design to be launched outside a project. :)

This is the case, for instance, for the create command in the ubuntu-project template: there is a pre-hook executed (see below) and then, we launch the template in the parent dir of the project directory. Be aware of that. :)

Hook system

Quickly supports some hooks. It enables to have some specific automation (part of code) executed before and/or after an execution of a command. They are Quickly Core builtin. Now, we just have one: pre_create, launched before any create function.

You can note that hooks aren't execute when calling the script for shell-completion and help.

pre_create creates the directory specified in the create command line and handle more complex cases like $ quickly create template folder1/folder2/projectname. Also, pre_create filters acceptable project names and populates .quickly file in the new project directory to put some generic parameters needed for Quickly Core compatibility handling.

So, if your template needs a Quickly project, you really should consider adding a create command which can be launched outside a project only. It will be a bad idea to create a project within an existing project, even if Quickly Core supports it. :)

.quickly?

This file should be located in the root project directory (it's how Quickly Core detects it, to be honest). The basic pre_create hook creates a file like that:

project = foo
template = ubuntu-project
format = 0.2.3

With that, we can store project name (which can differs with the folder case), template names, and Quickly format (corresponding to Quickly version) to handle migration.

You can add your own key/values pairs (again a convenient function is given if you develop your template in python) to help you in your template needs. The file format is the same than for quicklyconfig template file (comments, extra spaces, etc.).

tools to help you (if your template is in python)

Most of them are in quickly/templatetools and quickly/configurationhandler.

access and modify .quickly

configurationhandler is your friend for this one :)

The basic way is to import the module and load the content of the .quickly file:

from quickly import configurationhandler
if not configurationhandler.project_config:
    configurationhandler.loadConfig()

Here, we avoid to reload the configuration. You can do it if there are pending changes you want to forget. Then, you have an associated array called "project_config" and use it to retrieve some values:

print(configurationhandler.project_config['project'])

(if the key doesn't exist, it will return the usual no index found).

You can then add new values that you need in your own template by:

configurationhandler.project_config['foo']=bar

To save it, you can finally call:

configurationhandler.saveConfig()

All modifications will be stored by .quickly file within the current project.

handling easily help and shell-completion

For that, we have a handle_additional_parameters which takes function as optional parameters. Those functions should print help and handle shell_completion method. In the following examples, the functions are names "my_help" and "my_shell_completion", but that doesn't matter.

from quickly import templatetools
def my_help():
    print _("""Usage:
$ quickly change-lp-project

Enable to set or change the launchpad project binded with the current
ubuntu project.
""")
templatetools.handle_additional_parameters(sys.argv, my_help)

As you notice, some parameters are optionals. Here is the example will both functions:

def my_shell_completion():
    if len(sys.argv) == 3:
        print " ".join(get_supported_licenses())
def my_help()
     print("foo")
templatetools.handle_additional_parameters(sys.argv, help=my_help, shell_completion=my_shell_completion)

Get formated Quickly name of a project:

Very easy function to get your project name compatible with Quickly Core (this is the same one which is put in .quickly file)

from quickly import templatetools
print(templatetools.quickly_name(project_name))

An error is issued if the input is not supported currently by Quickly Core.

apply file permission to another file

This has been handy in the license command of ubuntu-project, it can interest others:

from quickly import templatetools
templatetools.apply_file_rights(fcopyright.name, fcopyright_out.name)

It applies to the second file path the permission of the first path file.

Launchpad and bzr

Disclaimer: we put support in Quickly Core itself for Launchpad and bzr, but nothing is loaded until you explicitly need it (and consequently, specify it) in your template. We will be happy to add other support from widely used system for template creator convenience. So, do not hesitate to propose your own binding.

We have some generic tools now for binding to launchpad project and creating/using credential so that template's developers don't become crazy if they want to use Launchpad in their template.

Basically, to setup launchpad credential and bind to a project (or use it afterwards), the code is:

# connect to LP (this create credential if needed, either, retrieve it)
from quickly import launchpadaccess
launchpad = launchpadaccess.initialize_lpi()

Once the user created his credential (or was connected automatically if it's not the first time it's called within Quickly), you have your launchpad python object to perform whatever you wish. It automatically targets staging if it was specified on the command line or by environment variable. It also setup bzr whoami if it was not done before.

All the "first configuration" step is done only once in Quickly: the credential is shared within every templates.

# get the project (choose and bind to one if not already done)
project = launchpadaccess.get_project(launchpad)

With that code, once connected to Launchpad, you will bind your project to a launchpad project. It will ask the user (the first time it's launched within a project) to what existing project he wishes to be bound, make a search with the string provided and propose some candidates to him. When done, you can play with the "project" python object in your template!

Staging stuff is also supported without any extra work. If you really need to know if you are on staging server, you can launch: ///launchpadaccess.lp_server/// (it can be "staging" or "edge"). No need to parse environment variable. :)

verbose mode

It's really easy to figure out if you are in verbose mode or not (specified by the user by environment variable or by using command line option):

from quickly import templatetools
if templatetools.in_verbose_mode():

in_verbose_mode() will be True of False, it's self-explanatory!

Well, Quickly Core is not so tiny as we can infer at first glance and a lot is covered under the hood too. It's not only a dummy command line parser as we are used to present it for simplicity, but you have been able to see that it has some advanced function as well.

Next week, we will see the first created template for Quickly. You already know some part of this one as I took it a lot of times as an example: yes it's the one called ubuntu-project! Back again to the user wave. :)

Yeah! It's already the 4th zoom of your Quickly trip and it's about shell completion.

Complete everything quickly

Quickly has an advanced shell completion tool. Currently, it's only binded to bash but plans are up to catch other shells (it's very easy, just call quickly shell-completion $0 from a script and perform little black magic to know the context).

You can reread part 2 if you want to understand every cases described below. Ensure as well you have Quickly 0.2.3.

After installation

Once Quickly is set up, you have to launch a new bash to get the bash completion working. This hasn't some workaround and it's the same with other tool (bzr, quilt...)

Ok, let's try a basic example:

Outside any project

quickly [Tab][Tab]
awesome commands    create      getstarted  help        quickly     tutorial

-> We get there all builtin and template commands which can be launched outside a project.

Here, commands, getstarted, help and quickly are builtin commands. Create and tutorial are ubuntu-project template commands.

Now, let's try a basic builtin command:

$ quickly commands [Tab][Tab]
<file list of my current folder>

Ok, that means that we have no parameter to specify or that the commands command don't support more advanced completion.

Testing a template command which can be launched outside a project:

$ quickly tutorial [Tab][Tab]
footemplate               ubuntu-project

This is because the tutorial command is (in my personal installation) present in two templates, so as this command can be launched outside a template, you need to specify a template.

Then, picking one template:

$ quickly tutorial ubuntu-project [Tab][Tab]
<file list of my current folder>

That means that tutorial command doesn't have advanced shell completion either

Note that you can also do:

$ quickly --template ubuntu-project tutorial [Tab][Tab]
<file list of my current folder>

This time, as you have already defined a template, Quickly Core won't bother you to propose a template after the tutorial command.

Advanced!

You should understand why this doesn't display more commands:

quickly -t ubuntu-project [Tab][Tab]
commands    create      getstarted  help        quickly     tutorial

What's the difference with the first example? There is no awesome command^[1]! It only lists builtin and ubuntu-project commands that can be launched outside a project. So, awesome command is certainly from another template than ubuntu-project in this case.

Inside a project

Common case

Let's give it a try:

$ quickly [Tab][Tab]
change-lp-project  getstarted         package            save
commands           glade              quickly            share
dialog             help               release            tutorial
edit               license            run

The list is made from builtin and associated template (here ubuntu-project template) command that can be launched inside the project (for instance, the create command is not listed).

From another template

As for help and launching a command, I can see commands from others templates, being in the same directory, that I can launch:

$ quickly -t footemplate [Tab][Tab]
commandfoo  getstarted  package     run
commands    help        quickly     tutorial

Here, I get builtin and footemplate commands that I can launch inside a project. Easy!

Advanced completion

As previously said, some commands can have advanced completion.

Command defined

They can defined it themselves (apart from the template part and command which is automatically handled by Quickly Core).

For instance, the license command from ubuntu-project defines an advanced (optional) parameters which is the license, Using shell-completion enable to discover every available licenses supported by ubuntu-project template:

Inside a project:

$ quickly license [Tab][Tab]
BSD     GPL-2   GPL-3   LGPL-2  LGPL-3

Command followed by command (headaches inside)

Do you remember part 2? I discussed about attributes on commands and we see before command followed by templates. There are also commands followed by another command. As of today, only the help builtin command has this attribute. But remember: help command is also a command followed by a template. Seems to be an interested case for testing shell completion behavior, isn't?

Outside a project

$ quickly help [Tab][Tab]
commands        help            toto
getstarted      quickly         ubuntu-project

help completion propose you with what you can get some help:

• directly builtin commands which can be launched outside any project
• available templates (for later completion)

$ quickly help ubuntu-project [Tab][Tab]
change-lp-project  edit               license            run
commands           getstarted         package            save
create             glade              quickly            share
dialog             help               release            tutorial

Here you get help on all builtins and commands from ubuntu-project template (as see in previous part for the help command)!

For bonus point:

$ quickly -t ubuntu-project help [Tab][Tab]
change-lp-project  edit               license            run
commands           getstarted         package            save
create             glade              quickly            share
dialog             help               release            tutorial

Same thing than previously, but using the -t option.

Inside a project

In this cas, help command completion will behave as expected after reading last chapter:

$ quickly help [Tab][Tab]
change-lp-project  edit               license            run
commands           getstarted         package            save
create             glade              quickly            share
dialog             help               release            tutorial

You have there all builtins and ubuntu-project template commands (given the fact that you are in a ubuntu-project "templated" project).

Bonus, for people who likes to complicate their life:

$ quickly -t footemplate help [Tab][Tab]
awesome     commands    getstarted  package     run
commandfoo  create      help        quickly     tutorial

Here, you are in a ubuntu-project "templated" project and you get help on all builtins commands and those from footemplate.

Miscellaneous

Option completion

Option benefit of course from completion:

$ quickly -[Tab][Tab]
-h          --help      --staging   -t          --template  --verbose   --version

Template completion

In addition to previous case of template completion, the -t/---template command has its own completion!

$ quickly --template [Tab][Tab]
footemplate               ubuntu-project

Good news is all of that is generically implemented in the Quickly Core itself. So, if you plan to create a Quickly template, you can get it also for free if you put right attributes to your personal commands (we will see that in a chapter 6).

Hope you will like this advanced completion setting (it gave me quite some headaches and a lot of trial/refactoring phases before getting it generically working and the code not being too ugly). Remember again that we will see how command can add to this completion their own level, as for help. :)

In next part, we will see miscellaneous things on the Quickly core itself.

This session is giving some fundamentals on Quickly, let's dive into them!

Two components: core and template

There is mainly two parts in Quickly: Quickly Core is a command line parser and context checker. It has builtin commands and can handle and launch template commands. Quickly templates are group of commands and files that are used on a certain purpose: you can create templates to manage your documents, a LaTeX skeleton, or to easily create projects gathering a certain number of technologies.

Consequently, using templates, you can create a project which will be binded to your templates. Templates can be written in whatever language you wish. That's the reason why we don't use optparse in Quickly Core component.

The application can be extended to run on other systems, and use different tools, etc... There is nothing stopping you from doing that. However, if you stray off the chosen path, some of the commands may no longer work for you.

We would love to see, for instance, a fedora-project template, gnome-project one, plasmoid-project, zeitgeist-plugin... and this tour will give you some trick to help you create one (in part 6).

But again, consider that you can create your template for everything, like managing your documents (without even creating any project). You can give some commands to create a new "company's set of documents" for a secretary ; he/she will complete them and then "quickly share" (for instance) for uploading it in the company's sharing documentation server. Quickly Core is not binding into developing only, power is completely given to template developers.

The ubuntu-project templates

The ubuntu-project template is the first template released today (some more coming for creating gedit plugins and ubuntu-game template).

The ubuntu-project template enables you to easily create a project using a given set of strong opinionated chosen technology ubuntu's people are mostly using:

• Python for the language
• pygtk for the UI framework
• Glade for the UI editor
• Gedit for the code editor
• bzr for version control
• Launchpad for code hosting
• desktopcouch for storage/database

The idea is to make choices (as Ubuntu make choices in their default applications list) for developers wondering what technology is "good to use for...". Choosing in a technology jungle can sometimes be a mess. Nevertheless, this is just a the skeleton: nothing prevents you for removing the desktopcouch part if you don't want to use it for instance (same for other pieces of technology).

It's also easy to create your own template from ubuntu-project to remove what part you don't want (if you are found of git and don't want to use bzr, for example). More on that in next sections.

Also note, there is no Quickly runtime or base class library. Using the Ubuntu Project won't bring in any dependency on Quickly itself.

Templates, context and command management.

General

So, we have builtin and template command and you can also be inside or outside a project. All that forms a context.

A project created with the create command will be associated with the template used in the create command like in:
$ quickly create ubuntu-project foo^[1]
This command can only be launched outside any Quickly project and needs a template to be specified on the command line.

Then, when you are in a project, you can launch $ quickly <command> to launch the <command> from the binded templates or Quickly builtin command. No need to specify a template.

Also, you can launch any command wherever you wish in the project hierarchy (subfolder, subsubfolder...), the command will behave the way it's designed.

Get the list of all available commands.

Nothing more easy, just run wherever you wish:

$ quickly commands
[builtins]      commands
[builtins]      getstarted
[builtins]      help
[builtins]      quickly
[ubuntu-project]        change-lp-project
[ubuntu-project]        create
[ubuntu-project]        dialog
[ubuntu-project]        edit
[ubuntu-project]        glade
[ubuntu-project]        license
[ubuntu-project]        package
[ubuntu-project]        release
[ubuntu-project]        run
[ubuntu-project]        save
[ubuntu-project]        share
[ubuntu-project]        tutorial

builtins are... builtins command and others are templates owning commands. You can even check there that commands is a builtin one.

Choosing the template

You can still launch commands from another template in your current project. Let's say you need the "awesome" command from the bar template to be launched in your current ubuntu-project "templated" project, you still can with $ quickly --template bar awesome^[2]

Attributes of commands/Advanced brain breaker :)

WARNING: this part can be seen as quite tricky. It's needed if you really want to understand the template and builtin commands behavior or want to create your own template. If you don't understand/want to read it, don't desesperate and just jump into the "Ok, you killed me, what do I really need to know?" section :-)

Command attributes

As already said, some commands (templates and builtin ones) can either:

• be launched outside a project only (case of "create" from ubuntu-project template command, for instance)
• be launched inside a project only (case of "release" from ubuntu-project template command, for instance)
• be launched outside or inside a project (case of "tutorial" from ubuntu-project template command, "commands" builtin command, for instance)

The check is done during command launch (and shell-completion filtering as well) to ensure user doesn't perform any mistake (as users make some mistakes sometimes, don't they? ;)). For instance, if you try to launch a command which can only be launched inside a project: didrocks@laptop:~/not_a_quickly_project$ quickly --template ubuntu-project release
ERROR: Can't find project in /home/didrocks/not_a_quickly_project.
Ensure you launch this command from a quickly project directory.
Aborting

Template command launched outside a project must be followed by a template if not specified as an option. Of course, this enables Quickly Core to know in which template to find the command. This will give:

$ quickly create ubuntu-project foo
                 ^^^^^^^^^^^^^^ ^^^
                     template  command arg

or:

$ quickly -t ubuntu-project create foo
          ^^^^^^^^^^^^^^^^^        ^^^
          template as an option  command arg

Same for tutorial command, which is an ubuntu-project command:

$ quickly tutorial ubuntu-project
                   ^^^^^^^^^^^^^^
                   template following command

or:

$ quickly -t ubuntu-project tutorial
          ^^^^^^^^^^^^^^^^^
         template as an option

Note: -t templatename can be set wherever on the command line.

As we will see in a later part, shell-completion automatically propose template commands that can be launched outside a project if you are outside a project, or inside if you are ... in a project folder. :)

As builtin commands are generalists, most of them doesn't need any template. But some have the attribute "followed by template" which will need also a template (example: 'help', 'quickly') specified on the command line.

An additional attribute we will se later is "followed by command" (case of the help command). There will be a dedicated part of the help.

Launch a template command outside a project

In case you launch a template command which is part of a template without specifying the template (either with -t option or following the command), you will have a message like that:
$ quickly tutorial
ERROR: tutorial command must be followed by a template and no template was found on the command line.
Candidates template are: footemplate, ubuntu-project
Arborting.

That means that both footemplate and ubuntu-project templates have a tutorial command and Quickly in all its kindness found them to help you. :)

So, then, you can try to launch (if quickly tutorial doesn't take any additional argument, which is the case): $ quickly tutorial footemplate or $ quickly tutorial ubuntu-project.

Ok, you killed me, what do I really need to know?

Phew, this was the harder part of Quickly's concept. Now, the following will seem to be really easy once you get this. In any case, shell-completion will only propose in the current context what you need/can launch (we will discuss that later). So, if you are lost, just let you guided by it, it will propose whenever template/command args you need to specified in the current context. :)

Only knowing what is a template and a project should be sufficient for a daily (and happy? ;)) Quickly user.

Next part will be on getting help on commands.

Well, coming back from vacation, I had a couple of hours to "kill" in the train.

I saw a few days ago the awesome work of Davyd Madeley on animating GTK+ and Clutter-Gtk from client-side-windows based on the first step from Alexander's Larson. Reading the comments some people say "this is sooooo cool, but totally unuseful".

That's the reason why I tried to figure out some pratical examples where some animations can teach about the component/widget the user is currently interacting with. Giving some blink effects so that people can understand a concept has already been successfull: take the example of the cube in compiz which has helped a bunch of GNU/Linux newcomers to understand what really a worspace is.

In my experience, the tab concept is quite difficult for some people like my mother, not having the habit of it (it has never come to her minds that it's like a traditional phone notebook). So, maybe some animations can help them to realize what it is.

I built Davyd's version of clutter-gtk and other stuffs and then, began to write some realistic animations on the GTK Notebook component. BEWARE: as the frame can't be currently reparented and as I need to have one actor by frame, the current implementation is very hackish and just there for some proof of concept (code here for all animations below).

The first one is just a fade in/fade out, very unobtrusive.

Ogg version here.

Second is a little more noticeable, with the new frame coming and overlapping the previous one.

Ogg version here

Third is maybe the best in term of representation: we change the current "sheet" (the frame) and put the new one in front:

Ogg version here

The two last ones are more for fun. Not that they don't represent (even maybe better than the previous one) the real behavior of such a component, but they take a lot of space on the screen:

Rotating from the left:

Ogg version here

An finally, rotating from the bottom:

Ogg version here

So, what do you think about those, does that bring a better user feedback? Maybe we can explore that way to make a properly binding between clutter and GTK for making such things. With Clutter, GTK components can be more interactive and attractive.

Of course, we still need a default fallback for not forcing clutter, though.

Vu que le site http://suivi.ubuntu-fr.org est tombé et n'est pas prêt de revenir à la vie, L'association ubuntu-fr vous fait passer les informations dorénavant par ce canal.

Comme certains le savent sûrement, le wiki d'ubuntu-fr est actuellement sous double licence GFDL et CC:BY-SA.

Or ces deux licences sont incompatibles (et notamment la GFDL oblige de lister le texte complet de la licence du wiki sur chaque page, ce qui n'est pas des plus commodes, vous en conviendrez). Nous sommes donc en état de violation de licence, tout comme wikipédia l'était.

Or, par la publication de la GFDL 3 en fin de l'année précédente, cette version permet de passer le contenu (sous certaines conditions comme la date de création, la volumétrie, etc.) en GFDL sous CC:BY-SA avant le 1er août 2009. Après avoir travaillé plusieurs mois avec l'équipe de wikipédia, nous avons pu lever que les clauses s'appliquent à nos deux wikis (même si ce texte a été premièrement rédigé pour wikipédia). Remplissant donc ces critères et pensant qu'une licence est beaucoup plus claire que deux, nous avons donc décidé de passer, à l'instar de l'encyclopédie libre, sous licence CC:BY-SA 3 et ainsi de régulariser ce qui devait l'être.

Par ce texte et dans cette phase de transition, il n'y a pas besoin de l'autorisation des contributeurs. Cependant, nous tenions à vous le préciser, pour que vous puissiez retirer tout texte de votre initiative dans le cas où ce changement de licence ne vous convenait pas.

Le changement s'effectuera fin juillet 2009 et nous tenons à votre participation et votre plus grande vigilance dès que vous copiez un texte sur le wiki afin de ne pas aller à l'encontre des licences et copyright, cœurd même du respect du logiciel libre.

Pour les intéressés, il y avait un excellent lien sur le site du framablog.

This is the transcript of kinouchou, a recent member of ubuntu party core team organizer, experiencing her first ubuntu party on the organizer side last May, for Jaunty Jackalope.

(Credit to tshirtman for the translation)

I started using Ubuntu 3 years ago, without ever being active in the community. After I went to the Ubuntu Party of November in Paris, I decided to take my share of community work. Even if I was well aware a Ubuntu Party (UP) was not improvised, I had not the slightest idea of all the connections under the hoods about the whole management. Here is a part of what's the Ubuntu party 9.04 of Paris looks like behind the curtain.

For me, It all started near of end of February, start of March, at the time of the launch of the new community site, ubuntu-party.org. Foundations where here, but a lot of things needed their share of care, and all the articles to write! Deadline? now!... Well I'm a bit exaggerating, we had a week, more than enough!

In the meantime, was the first IRL (in "real" life, whatever that mean) meeting for the preparation of the UP. This day, date and place for the event where chosen and booked; we just had to think about what to do, when to do it, and how to manage our place, simple details! :) It's not easy to create a planning, even being in agreement about what we are going to do, and it was not even the case for everything! So we had to juggle with schedules and rooms, which are not extensible. So we thank about lightning talks which were new. And for the communication plan, a flyer was anticipated, but we had to find the design, a printer (not the device) not too expensive, and a distribution plan. The good news was, March is a month full of events : Solution Linux, Intercite, Libre en Fête... As many occasions to make our advertisement. Obviously, as Ubuntu-fr (ubuntu-party is the events division of Ubuntu-fr) was present, we needed to make them up and find people to manage the stands.

April is already coming, 9.04 is nearer and nearer, and the second meeting happens. This time we start by going back on the March event, but the main subject is obviously the UP. Report on the website status, still a lot of articles to write. CDs! Yes do you remember why we are doing an UP? Because there is a new version of Ubuntu coming out. A French localised iso file and sleeve, and to put under press in time. Schedule is tweaked, slight changes are made and volonteers are recruited. Assessments are made about direction marks. This time UP is in the same as the "nuit des musée" (night of museums: all museums are open and free for some hours of the night), so the cité des sciences (which host the UP) proposed us to handle a nightly session. "Are we doing it? What are we going to do?", assessments on the associations that will be present. On the cost side, we have to count goodies (yes! it indeed cost money), communication and preparation costs of events (even if we try to get most of it for free), and small things as Ubuntu-fr servers and all what makes Ubuntu-fr alive. Choice of goodies is very important. This year, we have ubuntu-fr badges and updated mugs (with a very nice koala).

The more the deadly deadline approach the more we see the whole lot of things waiting to be done. Did all the lecturers confirm their presence? Woo! New planning change! New work-group ideas... well, we will save this for next time, no time left!

Jaunty comes out at least, and pressure rise up again. Finish the iso image and the sleeve, finish the paper schedule, open lecture inscriptions. There is a weird feeling of both wanting to be the 16th for being at the event, and wanting to be the 18th for all being ended, and be able to rest, at least. This sums up with the feeling that time pass to quickly and nothing will be ready in time.

End of May, last meeting, we only speak about the pratical organisation of the two days, mainly useful to new volonteers, for they need to know what to say and what to do. I only spoke about IRL meetings, IRC meetings being impossible to count.

The real day is here, everything is ready, or so. The general impression is not of very big crowd, but the public is really here. Some times are cooler than over, but no time to get bored. The two days passes at incredible speed, and all already finished. Times of the first reports, some thought we would have few people (we even polled on the probable outcome), but no! Despite the fact May is the month of exams and long week ends, this new UP gathered about 4000 persons like the November one!

Why this article only now? Well two weeks ago was the debriefing, a good way to know what went wrong and make it better next time. If we had 4000 people in May, although the period not being very favorable, November's one is likely to be out of magnitude, so we will need again many new people for preparations, design, disc image, website(s) and obviously the very day of the UP :).

Après quelques heures où le serveur faisait des siennes et un reboot manuel était devenu obligatoire, je n'ai aucune excuse pour procrastiner :)

Après une introduction par Jono, Mark et Scott James lors d'une session en plénière où la connexion Wi-Fi rencontrait quelques problèmes (ne jamais compter sur une connexion Internet valable quand vous tenez une conférence avec des geeks connectés massivement ;)), il était temps de commencer les sessions de l'UDS.

J'ai suivi quelques sujets dans les sessions environnement de bureau (desktop), où je vais pouvoir donner un petit coup de main ainsi que des sujets sur la communauté. Comment attirer de nouvelles personnes dans la communauté de développement de la distribution (où, comme on a l'habitude de répéter, il ne suffit pas d'être développeur !) ? Bref, des idées ont fusé et il ne reste « plus qu'à » les implémenter.

J'ai également participé passivement à la dernière session consacrée à Kubuntu (oui Anthony, c'était pour toi :p). Il se fait tard, il est temps d'avoir une bonne nuit de sommeil, vu que Christophe a mis hier soir plus de 3 heures à passer un niveau dans un obscure jeu en flash (oui, il était parti au départ pour bosser sur une carte, mais pas celle d'un jeu !)… On a donc pu dormir que 4 petites heures. Bref, l'UDS, c'est difficile ;)