Quickly

Summary

Quickly will offer a set of commands that can be issued by a developer to:

  1. Quickly get a new project started
  2. Quickly create a deb package
  3. Quickly upload or update a package to a PPA

The first project template will be ubuntu-project. The system will be simple to extend by adding to a template or creating new templates.

Release Note

Quickly is new in 9.10. Quickly makes it easy for developers to make new applications for Ubuntu, and to share those application with other Ubuntu users.

Rationale

It is currently very difficult for developers to get started building applications that work with Ubuntu. There is ample documentation on how to contribute to ubuntu itself, but there is no prescriptive guidance on how to best build an application for Ubuntu. The forums and other sources provide lists of many different options, but there is no trustworthy authority.

Once a program is written, it is quite difficult to get it to end users. Programmers can create debs and use PPAs, but these are technically complex operations, with confusing guidance and multiple choices.

Quickly strives to solve this problem by:

  1. Creating a canonical project that makes opinionated choices for the developer in terms of what tools to use, and how to use them.
  2. Make creating a deb very easy.
  3. Make creating a PPA very easy.

User stories

Betty wants to create a simple application to track pencil usage in her office, where they all use Ubuntu on their desktops. She runs the command "quickly new ubuntu-project pencils". This creates a stub project, including pointers to documentation, etc... She write the application using python and pygtk.

She uses the command "quickly deb". This creates a deb package for her, she tries it out and it works.

So she uses "quickly ppa". This prompts her to create a launchpad account. After which, the project is loaded into her PPA. Her colleagues then use the ppa to load the pencils app onto their computer.

She gets a feature request, and adds the feature. She increments the version number, and runs quickly ppa again. Her users get an updated copy through update-manager.

Assumptions

Toolkit and Language for ubuntu-project

The core template will be "ubuntu-project".

  1. python is the language
  2. pygtk is the framework
  3. glade-3 is the UI editor
  4. gtkbuilder is the binding library
  5. classes encapsulate windows and dialogs (rather than inherit)

Dependencies

  1. The ubuntu-project template should understand automagic python build system conventions and lay out projects in a compatible manner.
  2. Launchpad PPAs must be understood and effectively scripted.

Design

The primary design mantra of Quickly is that everything should be Fun and Easy.

  1. Convention over configuration
  2. Minimal and simple configuration files
  3. Tool agnostic (we are not building or integrating into an IDE)
  4. Reward every action with progress
  5. Make next steps visible

How a Template Works

A template is a set of commands and related content that is designed to set up a project from scratch for the user, as well as potentially containing commands for enhancing and changing the project. It is essentially a directory with a set of python scripts and supporting files that lives in quickly/templates.

The only required command is "new". The new command should create a directory for the user with the necessary files for a functioning program that can be extended and enhanced. It should also create a "quickly" file that contains the name of the template. This is used by the quickly.py script.

Templates rule detection

  • Template are looked for in those directories:
  • ~/.quickly/templates/
  • <quickly binary>/templates/

  • /usr/share/quickly/templates/

Implementation

  1. Implement the ubuntu-project template
  2. Implement new window command
  3. Implement new dialog command
  4. quickly command directing script
  5. wrap automagic python build script
  6. wrap ppa script
  7. create tutorial

Commands

General behavior

  • There are two types of commands: builtins and template commands.
  • Builtins commands are provided in builtins/commands.py.
  • Template commands are provided in <template_path>/<template_name>/<command>.py All commands can have hooks in builtins/commands.py, for instance foo() can have pre_foo() and/or post_foo().

On exemple is pre_new() command that will create the project folder and generate the .quickly file before the new() command is called.

The Quickly Script

quickly.py is essentially a simple command line parser. The general structure of a quickly call is: quickly <command>

When receiving a command it follows the following steps:

  1. Check if the command is a builtins one using no existing project ("new", "quickly"). If so, try to use the specified template.
  2. If not, it looks in the template specified by the -t option for a python script that matches the name.
  3. If no command is found, it looks in the .quickly file (if exists) and get the template where to look for a command.
  4. If the command is not found in the specified template, then quickly.py looks in a canonical commands directory ("builtins").
  5. If the command is still not found, quickly.py returns an error.

Remember that hooks in "builtins/commands.py" file are executed before and after the commands, if this is found.

quickly.py, therefore, has no inherent knowledge of specific templates or commands, and should, therefore, be quite easy to change and extend.

Also, even if you are in a project binded to "ubuntu-project", you can execute a "release" command from another template using in the project folder : quickly -t kubuntu-project release instead of quickly release.

quickly file

This file is create by pre_new() (see further) in a project directory. The general format is foo = bar

It can have commentaries with # following one instruction or in this own line. Parsing it and adding/changing one value must not change the general layout of it.

Some builtins commands do not rely on .quickly file (quickly new, quickly quickly)

Special command like new and quickly

quickly new enables to create a new project. The idea is to simplify the command line for it and quickly new ubuntu-project foo is far easier than quickly -t ubuntu-project new foo. The latter is still valid, but user will prefer quickly new <template_name> <project_name>.

Same with quickly quickly, which duplicate a template to another directory with a new name. quickly quickly ubuntu-project foo-template will copy "ubuntu-project" to ~/.quickly/templates/foo-template. Quickly generate the skeleton of a quickly template. This should jump start quickly template contributions, and help ensure they use the proper heuristics, etc...

Ubuntu-projects template

As said above, ubuntu-project relies on bzr + LP + ppa. But it should avoid technical terms in commands.

Required

  • New project: quickly new ubuntu-project foo

This create the .quickly file in a new foo/ directory with "template=ubuntu-project\nproject=foo" (this hook is in pre_new), then new setup a basic pygtk/glade python project.

This init a bzr repository and commit a first state. The commiter's name will be "bzr whoami" result, even default one. bzr whoami update path is:

  • binding to LP with user,
  • get bzr whoami, status it to default if it's "<some string> <current_user>@<current_hostname>". If not default, exit

  • then, set identifier to <launchpad_display_name> + <preferred_email_adress> (if public, if not, exit)

  • call bzr launchpad-login to set it to <launchpad_name>

Warning /!\ No Launchpad action is done yet. (or we will get tons of dummy empty project).

  • Save: quickly save

Create a snapshot using bzr (commit). Still no binding with LP. The commiter's name will be "bzr whoami" result. If LP binding is done (with next command, quickly release). This will push by default over the network to bzr repository of the team associated to the project (trunk if it's not a fix).

An option --offline, can be setup to continue to commit offline, even when LP binding is done.

  • Release: quickly release 0.1

This command commit locally, tag the revision, and then push over LP, creating a release, tar.gz and building the deb in the ppa (by default, with the same ubuntu release than the developper's one).

If the project is not yet binded to LP (information saved in .quickly file), try to setup launchpad credential (if needed). Then,it should only ask for a project name, seek for them and let user choose an already existing one.

  • Synchronize: quickly sync

This will bzr pull from lp trunk or fixed version (see below "quickly fix"). Only available after first release.

  • Change Ubuntu version: quickly set-ubuntu-version <ubuntu_version>

Setup the default ubuntu version we aimed for when creating a deb. The default is the result of "lsb_release -cs".

  • Build a package: quickly build

This will launch pbuilder to create a package locally.

  • Create New Window: quickly add window

  • Create a Dialog: quickly add dialog

Nice to Have

  1. New Widget
  2. Stub Events
  3. Remove project (which will remove the project and all related ressources in LP)

Other Templates

Only the ubuntu-project template is required for Karmic. However, the following templates would be nice.

pyGame

Quickly get started creating a game with pygame.

gedit plugin

Quickly get started with a new menu and/or pane in gedit. This would be great for programmers building their own tools.

Miscellanous

  • bash completion (in progress, with code/template introspection)
  • LP binding are in "builtins" as this can be shared between templates.

Test/Demo Plan

Project Creation

Steps

$quickly create ubuntu-project boo

Response

A project is created and run. The window is title "Boo". Note that the application called Boo should actually run.

Project Editing

Steps

$cd boo $quickly edit

Response

Gedit (or whatever is the default editor) should open. Only python files should open.

UI Editing

Steps

$quickly glade

Response

  • Glade opens. The project menu should list a BooWindow, as well as a preferences window and an About Window.

  • Note that this will not work if you go Applications -> Programming -> Glade

Running a Project

Steps

  • In Glade, edit the Boo Window slightly, for example, by deleting the big image in the middle.
  • $quickly run

Response

The application runs again, but the image is gone, or whatever the edit was is noticeable.

Packaging

Steps

  • Edit the Copyright file by adding a year and an email address
  • Edit the setup.py file by adding an email address
  • Save both files
  • $quickly package
  • After the .deb is created, run it to install Boo

Response

  • The deb is created and installs
  • Boo is available in the Accessories menu
  • Boo runs from the accessories menu

Unresolved issues

  • what shall be the name of the ".quickly" file?
  • Some think that a hidden file manipulated only with quickly commands would make the system less confusing.
  • Some think that hidden files are confusing and get missed when making tars, etc...
  • Do we want to handle team as well as lp project creation?
    • if more than one opportunistic programmer wants to use quickly to cooperate on a project, this is mandatory if they don't want to do it by hand in LP
    • This add more complexity and lots of corner case.

    -> seems not

  • Fix a release: quickly fix 0.1

This will created a derivated branch from 0.1 release bzr tag and ask the user to cd in it. This will mark some metatag in .quickly file. When quickly release (it's forbidden to specify a revision in this case, it will create 0.11 and push to another branch than trunk in LP, creating debs...)

  • -> seems not wanted

  • we have also to define a command to change the binded launchpad project (not having to change it manually in .quickly file).

BoF agenda and discussion

UDS NOTES

automagic python build system is under development as a separate project by pitti.

Pitti's BoF notes: lool: private PPAs? pitti: once LP supports it, it's easy; however, you can put a .deb on your company web server; PPAs are for "easy discovery" use case lool: right, so we need a non-PPA release method, outputting a .deb for instance

KDE support can be added with "quickly new kubuntu-project" (just a matter of adding templates)

  • use KAppTemplate

new functionality: quickly release -> bzr add new files, commit, tag as new release, update changelogs, upload to PPA (if configured)

promotion:

  • have a registry of quickly-based projects (code samples!)
  • update wiki instruction to point it out as easiest option
  • look at integration with ubuntu-dev-tools
  • install by default
  • add to github?
  • gedit is default editor -> provide access to quickly through menu

===== end of pitti's notes -- slightly updated by lool :-P ==== =====begin ken's notes========== Opportunistic programmer, generally different mindset than the systematic programmer

What is a opportunistic programmer?

  • Hobbyists
  • Creates simple quick applications
  • Iterate rapidly
  • Professionals
    • technical directors on movies
    • in-house tools written for very limited user-base

Application Layer Cake

  • How do end users find my app? - discovery and installation
  • How do I get my app to end users? - packaging
  • What language, APIs, editor, etc should I use? - Tools and APIs

iPhone has a great implementation, SDK to the app store

For ubuntu it is far more complex

  • Lots of choice in frameworks, editors, databases, etc
  • Confusing to learn how to package and distribute your application
  • Not easy for users to discovery your application (out of scope for quickly)

Current plans

  • Quickly - opinionated choice of frameworks, language, and coding style
    • python/pygtk
    • template driven
    • Uses the automagic python build
      • automagically creates simple deb packaging for python apps

Examples

  • iFlush
  • Pencil ordering app

Everything in quickly must be fun and easy

  • instant reward

Functions

  • new project
  • create deb
  • create ppa
  • add new window
  • add new dialog

Nice to have

  • add widget
  • save snapshot (perhaps commit/push a bzr branch)
  • stub events
  • other project templates
  • create a release, tarball, bzr tag, upload to ppa

How do we convice people that this is the way to create applications?

  • prominate link to "how to get started developing"
  • prove the ease of use, if Quickly is the easiest and fastest, it will win

Look at github for social ideas, but that is probably more of a github vs. launchpad discussion

Override default plugin perhaps make quickly a gedit plugin

What about Kubuntu?

  • integration with kapptemplate maybe?

=====end ken's notes==========


CategorySpec

DesktopTeam/Specs/Karmic/Quickly (last edited 2009-09-25 21:04:08 by rick-rickspencer3)