news aggregator

Paul Tagliamonte: Thanks, Valve (thvalve)

Planet Ubuntu - Fri, 2014-01-24 22:05

I took Valve’s offer up (by way of the kickass Collabora folks) for some games. I can confirm that I got them, and it looks like it’s working great.

Just want to give a shout-out and express my gratitude. I know it’s not something they had to do, so it’s super cool that they wanted to.


Alan Pope: January 2014 Core Apps Hack Day One – Reminders and Music

Planet Ubuntu - Fri, 2014-01-24 10:58

As David blogged yesterday, we’re having another round of Core Apps Hack Days for our Ubuntu Phone Core Apps

Each day we’re focussing on two apps, today that’s Reminders and Music, but as always we welcome contributions to any app on any day of the week!

In order to get started we’ve come up with some suggestions for new developers.

First off get your development environment setup as documented at which you can do either natively on Ubuntu 13.10 or 14.04 or in a Virtual Machine if you prefer.
If you have a Nexus device, you could either replace the legacy OS with Ubuntu using either of these guides – or

Next up take a look at some of these suggestions based on your area of interest and skill level.

We welcome translations for all our Core Apps. If that’s if interest you can find everything you need at and

If you find bugs in the apps you can look for existing bugs to confirm or fix at and, or file new bugs at and

You may find some bugs which have yet to be confirmed or triaged, we’d love your help there too.

You’ll find out-standing merge proposals on launchpad at and

If you’d like to take on a task then we have some work items in the blueprints which you can assign to yourself and get cracking on at and

You can find out more about the Core Apps Hack Days at the links at the top, and you’ll find all of us hanging out on #ubuntu-app-devel on freenode.

The Fridge: Trusty Alpha 2 Available for Testing

Planet Ubuntu - Thu, 2014-01-23 22:16

The second Alpha of Trusty Tahr (to become 14.04 LTS) has now been released for testers and early adopters.

This alpha features images for Edubuntu, Kubuntu, Ubuntu GNOME, Ubuntu Kylin, Xubuntu and Ubuntu Cloud images.

These are not to be used as stable systems but please do test for bugs to report. Always ensure your system is up to date before reporting bugs.


Edubuntu is the educational flavour of Ubuntu. It’s very similar to stock Ubuntu but integrates a lot of educational software, supports thin clients (LTSP) and offers an optional GNOME lashback desktop as an alternative to Unity.

The Alpha 2 images can be downloaded at:

More information on Edubuntu alpha 2 is published here:


Kubuntu is the KDE based flavour of Ubuntu. It uses the Plasma desktop and includes a wide selection of tools from the KDE project. In this LTS cycle the Kubuntu team are working on stabalising and bug fixing.

The Alpha 2 images can be downloaded at:

More information on Kubuntu Alpha 2 can be found here:

Ubuntu GNOME

Ubuntu GNOME is a flavour of Ubuntu featuring the GNOME desktop environment.

The Alpha 2 images can be downloaded at:

More information on Ubuntu GNOME Alpha 2 can be found here:


Xubuntu is the Ubuntu flavour with Xfce, a stable, light and configurable desktop environment.

The Alpha 2 images can be downloaded at:;/releases/trusty/alpha-2/

More information on Xubuntu Alpha 2 will be published here:


UbuntuKylin is a flavour of Ubuntu that is more suitable for Chinese users.

The Alpha 2 images can be downloaded at:

More information on UbuntuKylin Alpha 2 will be published here:

Ubuntu Cloud

Ubuntu Cloud images can be run on Amazon EC2, Openstack, SmartOS and many other clouds. Included with Alpha-2 are PPC64EL images.

Regular daily images for Ubuntu (Unity) can be found at:

If you’re interested in following the changes as we further develop Trusty, we suggest that you subscribe to the ubuntu-devel-announce list. This is a low-traffic list (a few posts a week) carrying announcements of approved specifications, policy changes, alpha releases and other interesting events.

Originally posted to the ubuntu-devel-announce mailing list on Thu Jan 23 18:40:13 UTC 2014 by Jonathan Riddell

Jason Gerard DeRose: How to enable perfect-forward-secrecy in Python 3.3

Planet Ubuntu - Thu, 2014-01-23 20:33

One of the many reasons to use Python3 is the ssl.SSLContext, which gives you quite comprehensive control of how you use TLS from Python.

As of Python 3.3, SSLContext supports perfect-forward-secrecy, which you can enable on your server-side SSLContext like this:

server_ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)

When implementing REST APIs, I highly recommend you secure them with TLS using client-side certificates for authentication. When you have control over both end-points, I recommend you configure TLS in a highly restrictive, modern way. Even though perfect-forward-secrecy must be enabled on the server-side, you can still configure your clients to only connect to servers that have enabled perfect-forward-secrecy (eg, by setting the ciphers to only include ECDHE variants).

For example, this is more or less the way that Dmedia will be configuring TLS for its server going forward:

server_ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
server_ctx.verify_mode = ssl.CERT_REQUIRED
server_ctx.options |= ssl.OP_NO_COMPRESSION
server_ctx.options |= ssl.OP_SINGLE_ECDH_USE
server_ctx.options |= ssl.OP_CIPHER_SERVER_PREFERENCE
server_ctx.load_cert_chain('/my/server.cert', '/my/server.key')

And this is how Dmedia will configure its client:

client_ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
client_ctx.verify_mode = ssl.CERT_REQUIRED
client_ctx.options |= ssl.OP_NO_COMPRESSION
client_ctx.load_cert_chain('/my/client.cert', '/my/client.key')
Python 3.4

In Python 3.4 (which will be Ubuntu Trusty), SSLContext supports TLSv1.2, and so for Python 3.4, I recommend you set the ciphers to 'ECDHE-RSA-AES256-GCM-SHA384', the big reason being that it's almost twice as fast.

For example, in a recent localhost-to-localhost benchmark I did (so Ethernet wouldn't be the bottleneck), I got:

ECDHE-RSA-AES256-SHA: 394 MB/second
ECDHE-RSA-AES256-GCM-SHA384: 740 MB/second

My recommended Python 3.4 server config is:

server_ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
server_ctx.verify_mode = ssl.CERT_REQUIRED
server_ctx.options |= ssl.OP_NO_COMPRESSION
server_ctx.options |= ssl.OP_SINGLE_ECDH_USE
server_ctx.options |= ssl.OP_CIPHER_SERVER_PREFERENCE
server_ctx.load_cert_chain('/my/server.cert', '/my/server.key')

And my recommended Python 3.4 client config is:

client_ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
client_ctx.verify_mode = ssl.CERT_REQUIRED
client_ctx.options |= ssl.OP_NO_COMPRESSION
client_ctx.load_cert_chain('/my/client.cert', '/my/client.key')

Benjamin Kerensa: Interview with Ubuntu Contributor Cody Smith

Planet Ubuntu - Thu, 2014-01-23 18:57

Cody at a Ubuntu Global Jam in 2013.

I recently reached out to Cody Smith who is a long time contributor to the Ubuntu Oregon LoCo. He has ran an Ubuntu Hour nearly every Friday for last couple of years and his passion for Free Software and getting people involved is contagious.


Benjamin: When did you first start contributing to Ubuntu and what was the motivation?

Cody: I started contributing around 2012 with bug reports, byte-size bug-fixes, and getting more people using Ubuntu (and Linux in general), my motivation was me wanting to give back to such a great community, and be a part of making Ubuntu better in any way I could.

Benjamin: Can you tell me more about yourself?

Cody:  I am a 21-year old college student with a thirst for the knowledge of how the underpinnings of Linux (and pretty much anything I enjoy using) work, I’ve been using Ubuntu since a little after 10.04 was released. Benjamin: You recently applied for Ubuntu Membership can you tell me how that process was for you? Cody: I’d be lying if I said the membership process wasn’t a bit nerve-wracking. but all in all, I’d say it went alright, to those looking to apply, make sure you have a decent amount of contributions and give the board as much info on the contributions as possible. Benjamin: What is your favorite desktop environment? Cody:  I don’t use a desktop environment more than a plain window manager, that said, I prefer the i3 window manager, fits how I do things perfectly. Benjamin: What are your plans for contributions to Ubuntu in the future? Cody:  my plans are to maintain what I currently do (hold Ubuntu Hours, submit bug fixes for betas, and just get people on board with Ubuntu), as well as taking on more challenging bug fixes, there’s just that sense of satisfaction when your bug fix even gets considered for inclusion in the OS, even more so when it’s included. Get Involved

Getting involved is easy, all you have to do is read our Development Guide, particularly these chapters will help you a lot: Introduction to Ubuntu Development, Getting Set Up and How to fix a bug in Ubuntu. Next…

Find something to work on

We run regular bug fixing initiatives, where you can get started on hand-selected bugs and point out other ways to find bugs to get started with.

Get in touch

There are many different ways to contact Ubuntu developers and get your questions answered. Don’t be shy and get to know us.

  • Be interactive and reach us immediately: talk to us in #ubuntu-motu on

  • Follow mailing lists and get involved in the discussions: ubuntu-devel-announce (announce only, low traffic), ubuntu-devel (high-level discussions), ubuntu-devel-discuss (fairly general developer discussions).

Stay up to date and follow the ubuntudev account on Facebook, Google+, or Twitter.

Xubuntu: Xubuntu 14.04 Alpha 2

Planet Ubuntu - Thu, 2014-01-23 18:44

The Xubuntu team is happy to announce the immediate release of Xubuntu 14.04 Alpha 2!

As often expected with very early cycle releases, this release has some issues which we will be working to resolve before the final release.

Notably, it is impossible to successfully use the Alpha 2 to set up an auto-resized system automatically. You will not be able to set the partition sizes.

Thanks to the 12 who tested and reported to the tracker for Alpha 2:

  • gridcube
  • irihapeti
  • j-bardales
  • jjfrv8
  • lderan
  • lyz
  • paulw2u
  • sergio-br2
  • slickymaster
  • texadactyl
  • wkrekik
  • elfy

We always need more testers so please consider contributing to our daily builds or to the next milestone! Learn more about testing here: Help us test Xubuntu 14.04 LTS

Known Issues
  • Top ruler missing from Abiword: 1261203
  • Keyboard Input Method closing unexpectedly: 1258751
  • Ubiquity window spans monitor width: 1260396
  • Desktop items have background: 1270261
  • Thunar not always automounting USB: 1210898
  • Resize bar missing when running autoresize install option: 1260473


Stuart Langridge: Saving the current state of your Ubuntu SDK app, with no effort

Planet Ubuntu - Thu, 2014-01-23 18:14

Earlier today I gave an example of how to use U1DB to save the state of your Ubuntu app. Now, U1DB is useful for actually storing actual data, right enough. But if you want to save state — which tab was showing, what was being typed into a text field, what was chosen in a dropdown, where a list was scrolled to — then that’s built right in 1 to the Ubuntu SDK.

It’s called StateSaver.

This isn’t used to store data, long term. It’s used to make your app automatically remember what position things were in. So quitting the app and restarting it, or switching to another and then switching back, means the app doesn’t reset to the front screen, doesn’t forget what you were halfway through typing in, doesn’t forget where you’d scrolled to.

To use it, just add to the Item you want to save things for. So, for example, if you want your ListView to remember the position it was scrolled to, do this:

ListView { id: mylistview model: someModel delegate: ListItem.Standard { text: "row " + model.index } "contentY" }

Just that one thing. Now your ListView remembers where it was scrolled to after a restart. You can do the same with a set of Tabs (just add "selectedTabIndex") or a TextField ( "text").

NB: this isn’t really for data saving. It might, or might not, be appropriate to use it for whether a switch is flipped or not. That’s a setting; when the switch is changed, you ought to be doing something with that information. Ideally you could drive everything, declaratively, off of whether the switch.checked is true, and if you can do that then StateSaver is the ideal place to have that info. But if you run a function when a switch is changed, then don’t use StateSaver to remember its state: use U1DB, and store the other stuff that changed alongside it. It’s about saving state, hence the name.

Saving the state of your app like this is an idea so good that other ideas gather at its feet to pray. I think that this should be turned on automatically for the “relevant” properties of each type of Ubuntu SDK widget, and if for some reason you don’t like it you can turn it off. Not for every single property, but for the ones where state makes sense: the scroll position for a ListView, the entered text for a TextField, the visible tab for Tabs. Small things like this are what make the difference between great apps and merely good ones. Any one individual app isn’t particularly harmed by not remembering this stuff; so many apps do not, on other platforms, that people are used to the idea of having their state thrown away. But if almost all the apps do do this, then the ones that don’t get called out on it and then it gets fixed, and that makes the whole platform better. It’s really important that we create a culture of desire for finished, polished apps for Ubuntu. If your app throws away where I was scrolled to, I want the developer to feel a bit embarrassed about that and immediately go to fix it. That’s what will make our platform feel consistent, feel tight, feel together, feel fun to use; the culture of pushing back on unfinished and unpolished and half-ready apps. Open source has historically not had that culture, but I’d really like to use a platform which does.

Importantly, though, for it to be reasonable for we users to require this of app developers, it has to not be really hard for app developers to do. This, taking complicated things and making them easy for app developers to implement, is what the platform is for. And StateSaver is a great example of it; the platform provides! I’m really impressed that this exists and is part of the SDK. (I’d be even more impressed if it did it automatically, as noted.) Good work, Ubuntu SDK team. This stuff needs more publicity!

Longer code example, which remembers which tab you were looking at, where the list is scrolled to, and what was typed in the text field:

import QtQuick 2.0 import Ubuntu.Components 0.1 import Ubuntu.Components.ListItems 0.1 as ListItem MainView { id: root width: height: Tabs { id: tabs "selectedTabIndex" Tab { id: t1 title: "StateSaver, 1" page: Page { id: pg ListView { id: lv model: 40 clip: true anchors.fill: parent "contentY" delegate: ListItem.Standard { text: "This is row " + model.index + ". Scroll to wherever." } } } } Tab { id: t2 title: "StateSaver, 2" Column { width: parent.width id: col2 spacing: anchors.centerIn: parent Label { text: "Enter your favourite pie" horizontalAlignment: Text.AlignHCenter anchors.horizontalCenter: parent.horizontalCenter } TextField { id: tf width: parent.width - "text" anchors.horizontalCenter: parent.horizontalCenter } } } } }


  1. how did I not know this existed! Big thanks to Florian for cueing me in

Stuart Langridge: Using U1DB in ListViews in Ubuntu SDK apps

Planet Ubuntu - Thu, 2014-01-23 16:24

After explaining how to use U1DB to store simple bits of information in Ubuntu SDK apps, and saying that that caters for 80% of my need for data storage, I should explain the other thing I do, which is to store dynamic data; documents created from user data.

To understand more about how to retrieve data from U1DB through Indexes and Queries, you can read the core U1DB documentation. Its code examples are for the Python implementation, and QML works differently for creating documents (as we’ve seen, QML is declarative; there’s no code to write, you just describe a document and it all works), but indexing and querying documents have the same underlying philosophy regardless of implementation, and the core docs explain what an index is, what a query is, and how they work.

First, a simple code example.

import QtQuick 2.0 import Ubuntu.Components 0.1 import U1db 1.0 as U1db import Ubuntu.Components.ListItems 0.1 as ListItem MainView { width: height: /* ---------------------------------------------------- Set up the U1DB database Declare a named document ---------------------------------------------------- */ U1db.Database { id: db; path: "simpleu1dbdemo2.u1db" } U1db.Index { database: db id: by_type /* You have to specify in the index all fields you want to retrieve The query should return the whole document, not just indexed fields */ expression: ["things.type", "things.placename"] } U1db.Query { id: places index: by_type query: ["*", "*"] } Page { title: "U1DB ListModel" Column { id: col width: parent.width spacing: Label { width: parent.width text: "Enter a place to add to list" horizontalAlignment: Text.AlignHCenter } Rectangle { id: ta width: parent.width - color: "white" height: inp.height * 2 anchors.horizontalCenter: parent.horizontalCenter radius: 5 TextInput { id: inp width: parent.width - anchors.centerIn: parent onAccepted: inp.adddoc() function adddoc() { /* Indexes do not work on top-level fields. So put everything in the document in a dict called "things" so that they're not top-level fields any more. */ db.putDoc({things: {type: "place", placename: inp.text}}) inp.text = "" } } } Button { text: "Add" width: ta.width anchors.horizontalCenter: parent.horizontalCenter onClicked: inp.adddoc() } } ListView { col.bottom anchors.bottom: parent.bottom width: parent.width model: places clip: true delegate: ListItem.Standard { text: model.contents.placename control: Button { text: "x" width: onClicked: { /* To delete a document, you currently have to set its contents to empty string. There will be db.delete_doc eventually. */ db.putDoc("", model.docId); } } } } } }

You type in a place name and say “Add”; it gets added to the list. The list is stored in U1DB, so it persists; close the app and open it again and you still have your place names. Click a place to delete it.

This covers almost all the remaining stuff that I need to do with data storage. There are a few outstanding bugs still with using U1DB from QML, which I’ve annotated in the source above, and at the moment you have to work around those bugs by doing things that you ought not to have to; once they’re fixed, this becomes more intuitive to use.

David Planella: The Ubuntu Core Apps Hack Days are back!

Planet Ubuntu - Thu, 2014-01-23 12:39

Core Apps Hack days are an easy way for app developers to get started contributing to one of the most important and visible parts of Ubuntu, and learn and share knowledge with an exciting community of some of the best Open Source developers around. As core app developer Riccardo Padovani, puts it:

I started to contribute to Ubuntu Touch with a Core App Hack Day in July and I still have not stopped!

Driven by the success of previous editions, we’re thrilled to announce another week of Ubuntu Core Apps Hack Days starting tomorrow, Friday the 24th of January

The goals

In one month’s time, the Mobile World Congress will bring a unique opportunity to present the Ubuntu phone and tablet to some of the most influential names in the mobile industry. It is also an opportunity to showcase a truly free OS and the stunning work our community of core app developers (and many others!) have already achieved.

Thus we’d like to set the theme for these Hack Days to Sprinting to MWC, and use them to focus on convergence and finishing off the set of features agreed upon at the last Ubuntu Developer Summit (UDS).

The schedule

We’ll be running a week’s worth of Hack Days, online at the #ubuntu-app-devel IRC channel, from 9:00UTC to 21:00UTC, focusing on two apps a day:

Get involved

There are many ways to making core apps even more awesome! If you want to contribute, choose the one that best matches your interests or skills. The first thing I’d recommend would be to run the apps on a device to get a feel for how they work. If you don’t have a real device to test, a good alternative is to use the Ubuntu emulator.

Once you’re familiar with them, here’s how you can start your journey to becoming a core apps contributor:

  1. Join the #ubuntu-app-devel IRC channel and say hi! >
  2. Find something to work on or ask someone on the channel. Here are some examples to get started

To learn more about contributing, check out the Hack Days page >.

Looking forward to seeing the new faces in the core apps project!

The post The Ubuntu Core Apps Hack Days are back! appeared first on David Planella.

Marcin Juszkiewicz: Xulrunner/AArch64 on a way to upstream

Planet Ubuntu - Thu, 2014-01-23 12:03

I finally sent Xulrunner support for AArch64 upstream. From 76KB patch I went to 14 patches with 132KB in total due to other diff options like more context lines.

Will not bother with whole history of a patch. It involved three external projects:

  • libffi (merged upstream long time ago, xulrunner needs to update their copy)
  • double-conversion (see Qt/AArch64 post for details) also update needed
  • libevent got fix for deprecated syscalls which needs to be merged into xulrunner’s copy

Splitting patch went quite easy thanks to help from Xulrunner developers: mstange froydnj Tomcat Ms2ger glandium which told me how to submit my patch, which already existing bugs to update and who assign to code reviews.

And for patches please go to dependency tree of bug #962534.

And one note: AArch64 big endian was not fully covered. Endianness info was provided in most places for both little and big options.

All rights reserved © Marcin Juszkiewicz
Xulrunner/AArch64 on a way to upstream was originally posted on Marcin Juszkiewicz website

Related posts:

  1. The story of Qt/AArch64 patching
  2. AArch64 porting update
  3. AArch64 port of Debian/Ubuntu is alive!

Stuart Langridge: A simple U1DB example for Ubuntu SDK apps

Planet Ubuntu - Thu, 2014-01-23 11:42

On Reddit, Aaron Hastings said:

One of the features I’d really like to implement is for the app [a timetable viewer for trains] to save state upon exit. In other words, if a user selected the “Abbey Street” stop, then exited, the app should remember to load Abbey Street on next launch. I’ll have to look into how that’s implemented in Ubuntu.

I’d use U1DB to do that. A simple example:

import QtQuick 2.0 import Ubuntu.Components 0.1 import U1db 1.0 as U1db MainView { width: height: /* ---------------------------------------------------- Set up the U1DB database Declare a named document ---------------------------------------------------- */ U1db.Database { id: db; path: "simpleu1dbdemo.u1db" } U1db.Document { id: lastPlace database: db docId: "lastPlace" create: true defaults: { placename: "" } } Page { title: "Simple U1DB demo" Column { width: parent.width spacing: Label { width: parent.width text: "Enter a place" horizontalAlignment: Text.AlignHCenter } Rectangle { width: parent.width - color: "white" height: inp.height * 2 anchors.horizontalCenter: parent.horizontalCenter radius: 5 TextInput { id: inp width: parent.width - anchors.centerIn: parent /* ---------------------------------------------------- Important part number one Retrieve the value from the declared U1DB document ---------------------------------------------------- */ text: lastPlace.contents.placename || "" /* ---------------------------------------------------- Important part number two Save a changed value back to the U1DB document ---------------------------------------------------- */ onTextChanged: lastPlace.contents = {placename: text} } } } } }

This mechanism fulfils about 80% of my data storage needs for Ubuntu SDK apps. You declare a database and a named document; you use the values in that document (documentQMLid.contents.fieldname) declaratively, and to save values, just set documentQMLid.contents.

Of course, you could do this with QML LocalStorage, but do you really want to be constructing SQL statements all day? I don’t. And if you use U1DB now, it keeps the door open for more complicated things later, such as syncing this data between devices, or storing more dynamic data and then querying it, which I should probably write another blog post about if there’s interest.

Sean Davis: LightDM GTK+ Greeter 1.7.1 Released

Planet Ubuntu - Thu, 2014-01-23 11:40

Progress continues on the development of the LightDM GTK+ Greeter.  The second release of the 1.7 development series adds even more customization options and stability to an already great product.

What’s New?

These new features build on top of what was recently added in 1.7.0.  For more information about that release, please see this post.

New Features
  • The “border-radius” property for the login window and power dialogs is now themeable with CSS.
  • Widgets now support a themed alpha channel for “fake” transparency.
  • Sessions are now represented by a graphical badge, similar to Unity Greeter
  • Languages are now represented by a country-code label.
Bugs Fixed
  • LP #1266449: greeter crashes on empty username
  • LP #1264563: switch-to-greeter does not set lock hint
  • LP #1264771: Password entry box is not defined as invisible in glade definition
  • LP #1267742: Screen artifacts appear after restart and cold boot
  • LP #1270530: Login screen has boxes instead of text when font is not set
Other Improvements
  • Improved username tooltips
  • Fixed memory leak in clock feature
  • Improved xscreensaver timeout functionality
  • Login button is now the “default” widget
  • Windows can no longer be positioned off-screen
Screenshots Download and Installation

The source code for LightDM GTK+ Greeter can be obtained from the downloads page.  Ubuntu users (Quantal through Trusty) can also install it from the Stable PPA using the following commands.

sudo add-apt-repository ppa:lightdm-gtk-greeter-team/stable
sudo apt-get update
sudo apt-get install lightdm-gtk-greeter

If you find any bugs, please report them on the bugs page.

Jono Bacon: On Accountability

Planet Ubuntu - Thu, 2014-01-23 01:12

Every so often I see a scenario play out that I find rather disappointing.

It works like this: someone posts a topic to their blog that is critical or controversial. This person can either be a community member, commentator, employee or otherwise; it doesn’t matter who the person is. Then what happens is a series of comments are posted to that blog entry from readers that are critical of the post, thus challenging the author on their views. The author then either deletes the blog entry or disables the comments based on the feedback. In other words, a viewpoint is shared, an invitation for comment is provided, but that invitation is then revoked when the author of the blog post is dissatisfied with the response from their readers.

I have seen this happen countless times over the years and I don’t like this.

I believe we should all be accountable for our words. Our words have the ability to inspire, to entertain, to challenge, but to also hurt. Actions have consequences, and so do words.

As such, when I see someone openly share their thoughts on their blog and invite their readers to provide comments, I see that as a wonderful demonstration of accountability and engagement; debate is a beautiful thing when executed with politeness and respect. To then close that door, seemingly because people disagree with you, is in my mind the equivalent of walking out of a room in the middle of a debate. The excuse when folks are criticized of this behavior is typically “it is my blog and I can run it how I like“.

This is true: it is your blog, and you can run it how you like, but the true measure of a person is not just in what they say, but also in the conversation and discourse that follows.

Now, there are two very important caveats to my view here. Firstly, abusive, threatening, or otherwise offensive content is a perfect candidate for removal and the commentator for banning. We should never tolerate this. Secondly, I can understand the removal of a blog post if there is a legal requirement to do so. In the majority of cases where I have seen posts removed or comments disabled though, it has been for neither of these reasons.

Speaking personally, I have never, ever, switched off comments on my blog posts or deleted posts. Even when the Internet has seemingly come to get me, or when the press pick up on something and are critical, or when I have made a mistake and felt embarrassed at the outcome…I have never switched off comments and never deleted a blog post. This is because I feel I should be and I am accountable for my words.

For me, this is an ethical issue; in the same way I won’t go and re-write or edit a blog post if I get criticism for it (outside of minor grammatical/spelling fixes). My posts are a time-capsule of my thinking at that point in my life. For me to go and edit them would be me re-writing history. A blog is not a regularly updated record of your views (like a book), it is chronological diary of your views and progression as a person. Consequently, my blog is filled with moments from my past that don’t reflect my views, experience, or ideas of today. Some of those posts are even embarrassing. But you know what, those posts stay unchanged, and I am proud that I have never compromised on this accountability.

So with this in mind, I have a simple suggestion for those of you who run blogs: either switch your comments off entirely or always leave them on, but don’t turn them off when you don’t like the reaction from your readers. Polite and respectful debate helps us grow as human beings, helps us evolve our ideas and perspectives, and makes us better people. Let history be our record, not our edited version of history.

Ubuntu Women: Evaluating Call Number Two!

Planet Ubuntu - Thu, 2014-01-23 00:30

So far, only two people left feedback and more would help us to evaluate if it is needed or not.  This why Call Number Two is being posted.

Several years ago the Harvest project was launched.

Harvest makes it easy to find low-hanging opportunities in Ubuntu. It aggregates the mass of todo lists we use every day so it’s simple to find and coordinate work.

Unfortunately in spite of efforts by Daniel Holbach and others on the project, it never really took off.

It is still a priority for us even a few months later since some of the major take-aways from our survey results and identified that a lot of folks still struggle on the technical side to find something small to work on. Silvia Bindelli remembered the Harvest project and in collaboration with me launched Project Harvest, an effort to evaluate the running harvest site. Once the evaluation is complete we will have a better idea of whether it will fit our needs and work to improve it.

Our current plan is as follows for evaluation stage:

  1. Find several people who are interested in getting involved and willing to be test subjects
  2. Have them visit and start browsing
  3. Once they’ve had a look through, have them report back about whether they find it intuitive to use and useful for finding things to work on
  4. Bugs (from “I can’t figure out how to use it” to “this feature would help a lot!”) can be reported to the Ubuntu Women mailing list (please sign up), in the Feedback section of the wiki page or directly to the bug tracker at

Please sign up and contact us on the mailing list or by adding your name to the wiki if you wish to get involved and join the discussion. We also often hang out in #ubuntu-women (unlogged) and #ubuntu-women-project (logged) on freenode.

Stuart Langridge: Notes on footnotes

Planet Ubuntu - Wed, 2014-01-22 16:53

I use footnotes quite a bit in my posts. Normally for snarky asides, I grant you, but I picked that habit up from Terry Pratchett.

They’re easy to add to WordPress; I use Andrew Nacin’s Simple Footnotes WP plugin, and then all you have to do is drop [ref]footnote text here[/ref] into the text of your post 1 and it takes care of numbering the footnote, displaying it at the bottom of the page, allowing you to link back and forth.

However, as Jake Archibald pointed out on Twitter, footnotes at the bottom of the page feel rather like a print media sort of thing. That’s useful, if someone prints your page out, or if they run it through some sort of “easy reading” service such as Readability or iOS Reader, or if your page gets turned into an ebook — we don’t want to remove that capability. But, as noted, scrolling down to the bottom of the page to read a footnote and then scrolling back up again is stupid. The Simple Footnotes plugin gets half a point for this by making the footnote number (a superscript 1, or whatever) be a link which jumps to the footnote for you, and each footnote has its own “return” link which takes you back to where you were. That’s great on a touch device. If you’ve got a pointer, we have the ability to hover, and this is what tooltips are for, so if we add title="text of the footnote" to the footnote number link, you can see the text of the footnote without having to click and jump around the page at all by just mousing over the number.

Footnotes with a properly-sized hit target

That superscript 1 is a pretty tiny target though, either to click or to hover over. It would be nice if the mouse target were bigger, but we don’t want a bunch of white space around the number. So, a little CSS:

a.simple-footnote { text-decoration: none; position: relative; color: rgba(255,0,0,0.7); /* cater for WP putting too much left spacing in before footnote numbers */ margin-left: -.2em; } a.simple-footnote::after { content: " "; position: absolute; display: inline-block; padding: 1em; margin-left: -1.3em; margin-top: -.3em; border: 1px solid transparent; border-radius: 2px; } a.simple-footnote:hover::after { background: rgba(0,0,0,0.2); border: 1px solid rgba(0,0,0,0.4); }

which I added to Admin > Appearance > Edit CSS in WordPress. Now you get a nice large hit target for your mouse, which lights up when you’re over it, and a tooltip, but your page still contains its footnotes properly when run through Readability or printed (which it might not if you were to use some sort of JavaScript popover library rather than the stuff that’s just built in to the browser and understood by accessibility tools).


  1. like this!

Aurélien Gâteau: What to do after the last image?

Planet Ubuntu - Wed, 2014-01-22 14:58

If you have used Gwenview before KDE SC 4.11 you might be familiar with the following situation: you are running Gwenview in fullscreen mode, pressing Space to go through a folder full of images. At one point, pressing Space does not do anything anymore... What's wrong? A quick move of the mouse to bring up the fullscreen bar reveals that you are on the last image.

A first solution

This would happen to me quite often, so during KDE SC 4.11 development period I decided to do something about it.

I initially wanted to show an on-screen notification to the user when trying to go past the last image, but it turned out to be complicated to do. If you are familiar with Qt development, you know behaviors such as going to the next image are centralized using QAction. You define the QAction once and then plug it in the menubar and toolbar. The QACtion also lets you define a keyboard shortcut. Why is it a problem? Because when you reach the last image, the action to go to the next image (let's call it goToNext) is disabled, which means its shortcut (rightfully) does not trigger anything, making it impossible to be notified of user attempts to go past the last image.

In 4.11 I settled for an alternative: the goToNext action would always be enabled, triggering it while on the last image would go to the first image and show an on-screen notification to let the user know he was now looking at the first image.

Not satisfied

After using this setup for a while, I was not satisfied with it: I realized I never want to go back to the first image, I just want to know I reached the end. Still it was nevertheless better than not getting any feedback at all, so I let it in. A post on Gwenview forum made me think about that again. The behavior change of the previous and next action broke user "bob p" workflow because the next and previous buttons were now always enabled.

So I set out to look at that annoyance again, and finally figured out a (hackish) way to get notified of shortcut presses when an action is disabled. This makes it possible to keep the goToNext action disabled while showing an on-screen notification to let the user know he reached the end of the image list.

The nitty-gritty details

To implement this I created a class named DisabledActionShortcutMonitor. This class monitors an action changes through an event filter. When the action is disabled, its shortcut is assigned to a QShortcut. When the action is enabled, the QShortcut shortcut is reset. It's not pretty, but it does the work.

disabledactionshortcutmonitor.h looks like this:

class DisabledActionShortcutMonitor : public QObject { Q_OBJECT public: /** * parent must be a widget because we need to create a QShortcut on it */ DisabledActionShortcutMonitor(QAction* action, QWidget* parent); ~DisabledActionShortcutMonitor(); Q_SIGNALS: void activated(); protected: bool eventFilter(QObject* object, QEvent* event); private: QShortcut* mShortcut; };

And here is disabledactionshortcutmonitor.cpp:

DisabledActionShortcutMonitor::DisabledActionShortcutMonitor(QAction* action, QWidget* parent) : QObject(parent) { mShortcut = new QShortcut(parent); connect(mShortcut, SIGNAL(activated()), SIGNAL(activated())); action->installEventFilter(this); } DisabledActionShortcutMonitor::~DisabledActionShortcutMonitor() { delete mShortcut; } bool DisabledActionShortcutMonitor::eventFilter(QObject* object, QEvent* event) { if (event->type() == QEvent::ActionChanged) { QAction* action = static_cast<QAction*>(object); if (action->isEnabled()) { // Unset the shortcut otherwise we get a dialog complaining about // ambiguous shortcuts when the user tries to trigger the action mShortcut->setKey(QKeySequence()); } else { mShortcut->setKey(action->shortcut()); } } return false; }

You use it like this:

QAction* myAction = /*...*/; // ... DisabledActionShortcutMonitor* monitor = new DisabledActionShortcutMonitor(myAction, QApplication::activeWindow()); connect(monitor, SIGNAL(activated()), SLOT(doSomething()));

doSomething() will be called whenever the user uses myAction shortcut while myAction is disabled.

That's it, I hope it helps you if you are in this peculiar situation. Comments on how to improve the current implementation are welcome.

PS: Code for this feature is currently in a review request on Gwenview reviewboard. If you are a KDE developer with a few minutes to spare, why not have a look at it?

Sean Davis: MenuLibre 2.0 Released, Trusty PPA Available

Planet Ubuntu - Wed, 2014-01-22 13:01

It’s been quite a while since I’ve had an update on the progress of MenuLibre.  Today, the advanced menu editor celebrates it’s 2.0 release.  Normally there’d be a change log after the break, but this really is a brand new application.  Read on to learn more.

The latest version of MenuLibre, 2.0!

What is MenuLibre?

MenuLibre is an advanced menu editor, similar to the Alacarte Menu Editor.  With MenuLibre, you can easily add, remove, and rearrange launchers, directories, and separators.  Powered by Python 3 and Gtk 3, it is the complete toolbox for editing menus in Linux.  It was developed to support every popular Gtk desktop environment, and has been verified to support Cinnamon, GNOME, LXDE, MATE, Unity, and Xfce.

  • Menu Management: Features expected of a “menu editor”
    • Easily rearrange menu items, submenus, and separators
    • Add new launchers, directories, and separators
    • Installed applications and directories can be hidden from the menu with the flip of a switch.
  • Adaptive Interface: A consistent look in any environment
    • In the GNOME desktop environment, the application menu is used to blend in as a typical GNOME application.
    • In Unity, the application can be controlled using the global menu and HUD.
    • Other environments will have basic application controls available within a “cog” menu.
  • Application Editor: Complete control over how your programs look and work
    • Includes each key outlined in the Desktop Menu Specification.
    • Tooltips provide additional information about each setting.
    • An easy to use icon selection dialog helps quickly customize each menu item.
Screenshots Getting MenuLibre

Ubuntu 14.04 users can install MenuLibre 2.0 from the Stable PPA using the following instructions.

sudo add-apt-repository ppa:menulibre-dev
sudo apt-get update
sudo apt-get install menulibre

For everyone else, the source package is available from here.  To install for a single user,

python3 install --user

To install system-wide,

sudo python3 install

Known Issues

There are a few things that haven’t quite been worked out yet.

  • Adding new launchers to the topmost menu level in Xfce
  • Certain combinations of gnome menu and python3.3 (such as the combo in Ubuntu 13.10) tend to crash after making a change.  It’s verified to be fully functional in 14.04

If you find any more bugs, please report them at the Launchpad Bugs page.

Mathieu Trudel: Call for testing: urfkill / Getting flight mode to rock on Ubuntu and Ubuntu Touch

Planet Ubuntu - Wed, 2014-01-22 00:17
Last month, I blogged about urfkill, and what it's meant to be used for.

The truth is, flight mode and proper killswitch (read: disabling radios on devices) handling is something that needs to happen on any device that deems itself "mobile". As such, it's one thing we need to look into for Ubuntu Touch.

I spent the last month or so working on improving urfkill. I've implemented better logging, a way to get debugging logs, flight mode (with patches from my friend Tony Espy), persistence, ...

At this point, urfkill seems to be in the proper state to make it, with the latest changes from the upstream git repository, into the distro. There is no formal release yet, but this is likely to happen very soon. So, I uploaded a git snapshot from the urfkill upstream repository into Trusty. It's now time to ask people to try it out, see how well it works on their systems, and just generally get to know how solid it is, and whether it's time to enable it on the desktop.

In time, it would be nice to replace the current implementation we have of killswitch persistence (saving and restoring the state of the "soft" killswitches) currently in two upstart jobs — rfkill-store and rfkill-restore — with urfkill as a first step, for the 14.04 release (and to handle flight mode on Touch, of course). In the end, my goal would be to achieve convergence on this particular aspect of the operating system sooner than later, since it's a relatively small part of the overall communications/networking picture.

So I call on everyone running Trusty to try to install the urfkill package, and file bugs or otherwise get me feedback on the software. :)

Benjamin Kerensa: Now we do know know…

Planet Ubuntu - Tue, 2014-01-21 22:15

Some months back Mark Shuttleworth blogged “At least we know now who belongs to the Open Source Tea Party ;)” and it inspired Lennart a developer to print some shirts and I decided I needed one too and so I had some made. Although the shirt for me is tongue in cheek expression I think its disappointing and absolutely contrary to open source culture to ridicule people who share their opinions on free software.

If we all agreed on how things should be done or what the better stack is then we wouldn’t have so much great free and open source software. There would be no MariaDB because everyone would be content with MySQL there would be no Kubuntu because everyone would be satisfied with Ubuntu and so on.

Victor Tuson Palau: [Ubuntu Touch] Update to Logviewer

Planet Ubuntu - Tue, 2014-01-21 19:49

I am pleased to announced that Logviewer is now published in the Ubuntu Touch store.  The app no longer runs unconfined but users “read_path” pointing to “/var/log/” and “/home/phablet/.cache/”. If you think there is another interested log path let me know and I will try to include it.

Also, one feature that landed by popular request is submitting a selected section of a log to pastebin , thanks to Popey for the image:


Subscribe to Free Software Magazine aggregator