Interns 2007

A Farewell

tannewt, August 24th, 2007

Well, today is my last day. I’ve thoroughly enjoyed my time here at CC. Thanks to everyone here at the office and elsewhere who I interacted with this summer. I’ve met a lot of innovative, hardworking folks and they all deserve a big kudos. While I’ve been here I’ve created liblicense which had been conceived for a while by Jon. I think its at a point where inclusion into content platforms is now the key. We’ve done three releases but technically four. None of this would have been possible without the help of Jason Kivlighn. Back at the University of Washington (UW) him and I were roommates and will be living in the same house this fall. Jason is a super coder who finished his own Google Summer of Code project about halfway through the summer. Instead of just fizzling out he helped me by revamping parts of liblicense and writing modules to support all of the formats we currently support. I wouldn’t have gotten nearly as far without Jason’s help. Before I bid farewell and move on, let me recap a bit of what I did.

Well, my primary project was liblicense. Basically, I was handed down the idea of tracking licenses on ‘the desktop’. I arrived to find tons of UI mockups created by Rebecca for my implementing pleasure. Before I began implementing the UIs I spent the first three or four weeks conceptualizing and implementing the core liblicense library. The first (and second) release was on July 13. After this release I began focusing on Gnome desktop integration. I really enjoyed seeing a frontend to the hardwork I did on the backend. Hopefully, more will be done. At the same time as I did the Gnome integration, Jason mirrored my efforts in KDE4. After the release of the gnome stuff and library changes on July 30, I moved onto Sugar integration. I’ve since finished the Sugar integration and the files are available here: . We’ll probably never officially release it due to its exclusivity to the Sugar interface. I’m proud of where liblicense has come. Like I’ve written before, I think that license awareness is important and liblicense is a small, important step in the right direction.

My other project which I volunteered to help with was the LiveContent liveCD. When I got here Tim was assigned the task of producing the new Creative Commons LiveCD with a target of LinuxWorld (August 8th) as a release date. After a week or so here I offered to technically advise the project. While my intention was to only be a reference I quickly became technically responsible for the CD and its creation. Although this was not what I had bargained for, it was well worth it. To create the CD we utilized livecd-creator, a Fedora LiveCD creator. It was a challenge for me to adapt to a different packaging system (from portage for Gentoo to rpm for Fedora). Additionally, although livecd-creator is a step in the right direction (like liblicense) it did not fulfill all of our needs and resulted in some hacky scripts to build the CD. To counter those frustrations I added an easter egg to the CD which I will not disclose. :-D Having Tim orchestrating the entire project also reduced my stress level quite a bit. However, it is quite nerve-racking creating a LiveCD to be duplicated 1000 times and pushed by both Creative Commons and Fedora. All in all, it turned out great. The next version(s), which I will not be a part of, should be even better.

I’m moving on. While I’ve enjoyed my time here at CC, I’ll not be continuing on these projects. I’ve got a somewhat short attention span for projects and it has run dry for both LiveContent and liblicense. Over the last few days I’ve been brain dumping so that Asheesh can pick up where I left off. This move should be good for the projects because Asheesh is a very smart and driven person. You should check out his current project jsWidget. Since I’m done, I’ll be driving home to Washington (the state not the district) tomorrow morning. When I get there I’ll be enjoying home and working on educational materials for teaching Python in the intro Computer Science course at UW. After that I plan on focusing on my own projects.

Lastly, I’d like to thank everyone here at CC. Alex, our graphic designer, has been a huge help on both liblicense (he wrote the Ruby bindings) and LiveContent ( he did the sweet packaging). Nathan Yergler’s flexibility allowed me to switch between projects on my own will and thus keep stress to a minimum. All of the other CC interns, Tim, Rebecca, Cameron and Thierry, made this summer great because we bonded as a group as we worked hard and hung out at various events. Finally, Jon has been an immense help by entertaining my questions, dealing with my grumpiness and encouraging me on both of my projects. As always, there are many others who made this a great experience but the folks mentioned are those who I worked with day-to-day. Thanks, everyone. I hope that what I started while here at CC sees much use in the future. Cheers.

Comments Off

Semantic Annotations on CC Wiki

tpkennes, August 9th, 2007

We have just implemented Semantic MediaWiki on our wiki. SMW allows additionnal markup into the wiki-text and improve the overall quality and consistency of the wiki. It may appear to make things more complicated but it actually makes easier for users to find more information. Using SMW’s own inline querying tools, a page could then be created that lists almost everything you want.

When you add contents as for now, please use semantic annotations. We have created special pages for you that will help you to easily do that.
At the moment, you can find instructions for Books, Content Curators and Content Registry.
Do not hesitate also to use our forms, there are much more easier.

Comments Off

Licensing on the Gnome Desktop

tannewt, August 3rd, 2007

A few days ago we released version 0.3 of liblicense. This version focused on bringing liblicense onto the desktop and improvements to make that a satisfying experience. The primary things we added to integrate into Gnome were a generic GTK license chooser widget, default license chooser, and nautilus extension. These things combine to demonstrate the power of licensing on the desktop. Additionally, we added optional sqlite3 cache support to speed up the get_licenses() function primarily. Here is a run through of the changes.

The GTK license widget is used extensively throughout the integration. The widget provides an interface to the license choosing functions in liblicense. A user selects a license by toggling various attributes.

GTK Widget in Default Chooser

This is the default license chooser. The GTK widget is in the frame above the buttons. The widget provides get_license and set_license which in this case is used to set the default license for the system. Ideally, the default system license would be used by applications when they embed license data upon save. However, that is ideal and not implemented yet.

The default license is used in the nautilus extension. The default license is used in the file properties license tab whenever a file doesn’t have a license set. The properties tab also utilizes the GTK widget. Once the user selects a license for the file(s) and closes the dialog the data is written to the files using the liblicense io modules. These are C modules which embed and extract license data in particular file formats. Having numerous modules provides decent coverage of file formats. Currently, if Exempi support is enabled, all files can be handled by creating an XMP sidecar file in the absence of any other means of license storage. We’ve also considered other means of license association but see embedding as the ideal option. Here is a screenshot from nautilus.

Nautilus File Properties

The second aspect of the nautilus integration is license loading upon folder open and resulting emblems. All the extension does is reads the license from every file nautilus loads and tags Creative Common’s licensed files with the CC logo and non-CC licensed works with our license icon. Here is a screenshot of the emblems.

Nautilus CC emblems

Thats about it. We’d love feedback before our next release (0.4). On the CC wiki we have a running list of things to do. You can get liblicense 0.3 from the cctools download page The liblicense home is also on the CC wiki available here. Its currently available in source packages, rpms and ebuilds and will be available in debs by the end of today. Lastly, there is a video of liblicense in action on youtube.

1 Comment »

OpenID on the CC Wiki

tpkennes, July 26th, 2007

Creative Commons’ wiki is now an OpenID enabled-site. Don’t hesitate – if you don’t have one yet – to create an OpenID account. There are severals OpenID providers so merely choose one from the list below :

VeriSign Personnal Identity Provider

A really nice screencast by Don McAllister explaining how to use OpenID can be viewed here.

Edit:  Another screencast from Simon Willison

1 Comment »

liblicense 0.2

tannewt, July 13th, 2007

Its here. We just released our first version of liblicense. Its pretty basic but should demonstrate what it’ll do. With the next version, 0.3, we’ll clean up things we’ve spotted already and also things that we’ll discover while we build some apps on top of it. Minimally, 0.2 has a command line program, license, which can be used to get, set and list licenses. We’d love feedback on the code itself and its greater role in the desktop. Please simply reply to this post.

The source files are available on sourceforge.

Comments Off

Semantic Videowiki

ml, July 6th, 2007

Don’t get too excited by the post title, just pointing out a nice 5 minute video (mp4) from Oxford Geek Nights explaining the basic features of Semantic Mediawiki. Thierry is experimenting with SMW features on the CC Wiki.

Comments Off

Liblicense is alpha!

tannewt, June 29th, 2007

Over the last week a lot of progress has been made on liblicense. Yesterday Jason and I got the module_read and module_write functions working with a stub io module and an XMP sidecar module. Tuesday and Wednesday I got the library’s system license functions working. Today I did some memory leak plugging and wrote out the system default functions. Nearly every part of the library works as planned. While its still rough, the bulk of the library work is done.

The most common data structure I’ve been using is a null-terminated list (really an array) of strings (char*). Yesterday I wrote out some common methods to be shared throughout the library. These are in list.c. My hope is that these common functions will allow the other code to be cleaner. Next week I plan on fixing up system_licenses.c to use the list functions. At the moment it is the largest, ugliest and leakiest of all the files. That will all be fixed Monday.

After the code cleanup on Monday the much more exciting task of creating modules and clients of the library begins. We’d like to support embedding in as many file formats as possible. Without this ability, the license tracking only works locally. One of the most useful libraries so far is Exempi which can embed in a number of formats. Jason wrote an Exempi liblicense module yesterday. On my list of clients to do is a Gnome Control Panel system default, Nautilus license select, Sugar license select and Creative Commons default license chooser. Am I missing anything important? Where could licenses be integrate besides this? Perhaps Amarok or an equivalent? ccHost? Let me know what you think.

Comments Off

System Integrated Licensing

tannewt, June 19th, 2007

I’ve been asked, as a tech intern here at Creative Commons, to create a way of locally tracking file licenses on a system. A while back Jon wrote down his ideas about system-wide license tracking on the Creative Commons wiki. The purpose of this system would be to provide an interface for developers to access the available licenses on a system. Additionally, like the existing online license chooser, this library, called libLicense, will feature a way to choose a license through toggling certain flags available for a family of licenses. Naturally, the first family available will be the Creative Commons licenses. The larger goal for the summer is to utilize this library in a few initial systems. Currently, I’m looking at integration into Gnome and Sugar (from the One Laptop Per Child project). This further work will occur after libLicense is working.


To run libLicense the data of all the licenses will need to be stored in some sort of fashion. My initial thought is this:

  • All data will be stored in a directory. On Linux this directory would be /usr/share/licenses . (This is borrowed from Jon’s thoughts.)
  • Families of licenses will be stored in a subdirectory of the licenses directory. For example, the Creative Commons licenses would be stored within creative_commons.
  • Within these family directories each specific license will be stored in a file with the naming scheme <bitcode>-<short name>-<jurisdiction>-<locale>.license . These files will store the license uri, name, status (active or retired), description and legal text. How this will be stored is up in the air. My intial thoughts include separating each attribute on a line or having a format similar to .desktop files.
  • In addition to storing license data, some family information must be stored, namely the family bit flags. In the case of the Creative Commons licenses, the bit flags would be Attribution, Share-Alike, Non-Commercial and No Derivatives. They would combine to create the bitcode present in the license filename. These bit flags would be the heart of the license chooser logic. If the combination does not exist, the flags are incompatible.

The library would potentially have these functions:

get_jurisdiction(uri) - returns the jurisdiction for the given license.
get_jurisdictions(short or bitcode) - returns the available jurisdiction for the given short name or bitcode.
get_locale(uri) – returns the locale for the given license.
get_locales(jurisdiction, short or bitcode) – returns the available locales for the given jurisdiction and short name or bitcode.
get_name(uri) – returns the name of the license.
get_version(uri) – returns the version of the license.
get_versions(short, jurisdiction) - returns the available versions for the given short name or bitcode and jurisdiction.
get_short(uri) - returns the short name for the given uri.
has_flag(attribute,uri) – returns if the flag is set for the given uri.
family_flags(family) - returns the flags available for a given family.
family(uri) – returns the family the given uri belongs to.
get_notification(uri[,url]) - returns the notification string for the given url with an option to provide a verification url.
verify_uri(uri) - returns whether or not the given uri is recognized by the system.
get_license(family,flags, jurisdiction,locale) – returns the uri which satisfies the given attributes.
get_all_licenses() - returns all general licenses available.
get_general_licenses(family) - returns all general licenses in a family.
get_families() – returns a list of available families.

Did I miss something? Does something not make sense? Please post a comment.