November 8, 2010
Some of you may be interested in a guest article I wrote for the VisionMobile blog reviewing the state of MeeGo eight months after its announcement: “The MeeGo Progress Report”
On the state of the MeeGo application developer story:
From the point of view of tools, documentation and software distribution channels, MeeGo is undoubtedly behind its primary competitors – but for such a young project, this is to be expected. The success of the project among application developers and the free software community will depend to a large extent on the project’s ability to fill these gaps and provide developers with an excellent development experience.
On the openness of the project:
[…] In the mobile platform development world, it is fair to say that MeeGo is second to none in terms of its open development model.
On comparisons with Android and iOS:
It does not feel fair at this point to compare MeeGo, a project which came into being 8 months ago, with iOS or Android, but this is the yardstick which will be used when the first MeeGo smartphone comes on the market. The project has come a long way since its inception, in particular in working towards an open and transparent development model. There is still some way to go but improvements have been happening daily.
July 2, 2010
community, freesoftware, gnome, maemo, work
A few days ago, I took the risk of setting off alarm bells on the GNOME developer training sessions planned for GUADEC this year. It was a risk, and comments from the naysayers reminded me that it’s easier to do nothing than it is to take a risk. I’m happy to say that the risk paid off.
Thanks to all who spread the word, a couple of prospects I was aware of confirmed their presence on the course, and I received a new group booking. The training is now feasible, and we are confirming that it will happen. There is still room on the course, and I expect to sell a few more spots in the coming days.
I did get one interesting suggestion in a Twitter reply to the announcement, and I’ve adopted it. If you are interested in attending one or two of the modules (say, community processes and the GNOME platform overview, but not the practical session or Linux developer tools), you can do so for the much lower price of €400 per module and €750 for two modules, not including a GUADEC registration.
Anyone who would like to avail of this offer, please contact me, and we will take care of getting you signed up.
Thank you all for your help and support!
June 16, 2010
community, freesoftware, General, humour, maemo
Who knew that educating people in simple sabotage (defined as sabotage not requiring in-depth training or materials) could have so much in common with communicating free software values? I read the OSS Simple Sabotage Field Manual (pdf) which has been doing the rounds of management and security blogs recently, and one article on “motivating saboteurs” caught my eye enough to share:
- The ordinary citizen very probably has no immediate personal motive for committing simple sabotage. Instead, he must be made to anticipate indirect personal gain, such as might come with enemy evacuation or destruction of the ruling government group. Gains should be stated as specifically as possible for the area addressed: simple sabotage will hasten the day when Commissioner X and his deputies Y and Z will be thrown out, when particularly obnoxious decrees and restrictions will be abolished, when food will arrive, and so on. Abstract verbalizations about personal liberty, freedom of the press, and so on, will not be convincing in most parts of the world. In many areas they will not even be comprehensible.
- Since the effect of his own acts is limited, the saboteur may become discouraged unless he feels that he is a member of a large, though unseen, group of saboteurs operating against the enemy or the government of his own country and elsewhere. This can be conveyed indirectly: suggestions which he reads and hears can include observations that a particular technique has been successful in this or that district. Even if the technique is not applicable to his surroundings, another’s success will encourage him to attempt similar acts. It also can be conveyed directly: statements praising the effectiveness of simple sabotage can be contrived which will be published by white radio, freedom stations, and the subversive press. Estimates of the proportion of the population engaged in sabotage can be disseminated. Instances of successful sabotage already are being broadcast by white radio and freedom stations, and this should be continued and expanded where compatible with security.
- More important than (a) or (b) would be to create a situation in which the citizen-saboteur acquires a sense of responsibility and begins to educate others in simple sabotage.
Now doesn’t that sound familiar? Trying to convince people that free software is good for them because of the freedom doesn’t work directly – you need to tie the values of that freedom to something which is useful to them on a personal level.
“You get security fixes better because people can read the code”, “You have a wide range of support options for Linux because it’s free software and anyone can understand it”, “Sun may have been bought by Oracle, but you can continue to use the same products because anyone can modify the code, so others have taken up the maintenance, support and development burden”, and so on.
Providing (custom tailored) concrete benefits, which comes from freedom is the way to motivate people to value that freedom.
In addition, the point on motivation struck a cord – you need to make people feel like they belong, that their work means something, that they’re not alone and their effort counts, or they will become discouraged. A major job in any project is to make everyone feel like they’re driving towards a goal they have personally bought into.
Finally, you will only have succeeded when you have sufficiently empowered a saboteur to the point where they become an advocate themselves, and start training others in the fine arts – and this is a major challenge for free software projects too, where we often see people with willingness to do stuff, and have some difficulty getting them to the point where they have assimilated the project culture and are recruiting and empowering new contributors.
For those who haven’t read it yet, the document is well worth a look, especially the section on “General Interference with Organisations and Production”, which reads like a litany of common anti-patterns present in most large organisations; and if you never knew how to start a fire in a warehouse using a slow fuse made out of rope and grease, here’s your chance to find out.
May 19, 2010
community, freesoftware, gnome, guadec, maemo, work
I’m delighted to announce the availability of GNOME Developer Training at GUADEC this year. It’s been brewing for a while, but you can now register for the training sessions on the GUADEC website.
Fernando Herrera, Claudio Saavedra, Alberto Garcia and myself will be running the two-day course, covering the basics of a Linux development environment and developer tools, the GNOME stack, including freedesktop.org components, and the social aspects of working with a free software project, being a good community citizen, getting your code upstream, and gaining influence in projects you work with.
The developer tools section will go beyond getting you compiling the software to also present mobile development environments, and the tools you can use to profile your apps, or diagnose I/O or memory issues, dealing with the vast majority of performance issues developers encounter.
This is the first time I have seen a training course which treats the soft science of working with free software communities, and given the number of times that people working in companies have told me that they need help in this area, I believe that this is satisfying a real need.
We are keeping the numbers down to ensure that the highest quality training & individual attention is provided – only 20 places are available. The pricing for the training course is very competitive for this type of course – €1500 per person, including training, meals and printed training materials, and a professional registration to GUADEC, worth €250.
If you register before June 15th, you can even get an additional discount – the early bird registration price is only €1200 per person.
I’m really excited about this, and I hope others will be too. This is the first time that we will have done training like this in conjunction with GUADEC, and I really hope that this will bring some new developers to the conference for the week, as well as being a valuable addition to the GUADEC event.
May 3, 2010
community, freesoftware, maemo
While I’ve occasionally been critical of Ubuntu as a project, it is a distribution with very open processes, for the most part.
I’d like to compare the experience of a casual Ubuntu user, an engaged Ubuntu user, an Ubuntu developer, and an upstream application developer to the equivalent MeeGo or Maemo experiences.
The casual Ubuntu user gets regular stable updates on a predictable schedule, with long-term supported versions less frequently, but still on a predictable schedule. Stability, releases, this user doesn’t want to know what happens behind the scene, he wants to get software when it’s “done”.
The engaged Ubuntu user can activate an unstable development distribution, and see the work going in as it’s being done! He updates daily, gets the latest and greatest, and occasionally stuff doesn’t work, but he doesn’t mind. The information how to do this isn’t on page one of ubuntu.com, but it’s there, and engaged users tell each other about it.
The Ubuntu developer can participate in the creation of the process by packaging his favourite software, pushing it through a public (although occasionally real-time & in-person) process for inclusion in the holy grail – default installation, or presence on the install CD. He can take care of packaging, shepherd the package through QA, ensure that problems get reported upstream and in general ensure that his package is a good Ubuntu citizen. Even if he doesn’t get the package in the default install, which is quite tough, he can follow public community processes to have it available in the Universe, available to every single Ubuntu user through a simple search of available applications.
The upstream developer doesn’t really care that much about Ubuntu. He develops his application, sees bug reports coming in from users & developers & downstream packagers. He adds features, and concentrates on what he loves best – coding the best app he can.
Now, compare that experience to Maemo, to see how we compare:
For the casual user, not much changes. He gets the software on a device, when it’s “done” (and the definition of done is considerably different for a phone than a PC distribution).
For the engaged user, who wants to follow the bleeding edge, the story gets murkier. In the Maemo world, hardware and software releases have been closely related. Without a Beagleboard or a prototype N900, Fremantle wouldn’t have been very useful. But even operating system updates like the upcoming long awaited PR1.2 are not packaged and prepared in public, so even existing N900 owners can’t follow along with the cutting edge.
There is a promise that the first release of MeeGo will work well on the N900, so potentially there is an opportunity for the engaged MeeGo user to follow along with unstable development – on condition that, like the engaged Ubuntu developer, they’re prepared for the occasional bricking & reflash. But the UX software for MeeGo is being prepared for release – we are told that some closed components are being opened, some others are not ready for release yet. So it is not (yet) possible for an engaged MeeGo or Maemo user to follow along & install a base alpha or beta distribution and update or reflash regularly.
For packagers who would like to propose their software for inclusion in the default repository, or even on the default install, of MeeGo or Maemo, there is not (yet) a clear path to get involved in the process. I could start working on a Maemo port of QuteCom, Shotwell or some other software, but if I did, there’s no way for me to get that software included by default. The current Extras/Extras-testing policy of Maemo has been heavily criticised by some developers – so it might not even be easy for me to make my software available to a large number of Maemo issues.
The upstream developer experience doesn’t change that much. Upstream developers still shouldn’t care about what packagers are doing, and should be concentrating on making the best apps possible. But for major parts of the MeeGo platform, namely the UX projects, the upstream and downstream will be hard to separate. As an upstream developer, I care about being able to follow commits, read Changelogs, do code review, develop and propose features, fix bugs and so on, in the open. For unrelated upstream projects, things also change – due to form factor and UX guidelines, the developer really needs to do a tailor-made UI for MeeGo or Maemo, requiring effort not being spent on features. And because you’re doing embedded development, your development environment becomes that much more complicated, with emulators and cross compilers and SDKs.
The embedded world is a special place, a lot of things change from desktop development, and some of those changes come with the territory. You’re going to have to work with a device emulator, and anything that requires a SIM card, the GPS, camera, accelerometer or any other hardware features, well, you’re going to have to wait for a device to make 100% sure those work. But we can certainly bear in mind the Ubuntu user experience(s) when we are designing the MeeGo community, and ensure that their experience is just as open.
That means open code, and more importantly open processes. It means an engaged user being able to use software that isn’t ready, a packager being able to propose software for inclusion in the OS and ensure its availability to all users of the distribution by following a well defined process, and a developer having a great experience helping to develop great applications.
March 23, 2010
community, General, maemo
The voting tokens have just been sent out for the Q1 2010 Maemo Community Council elections.
I already have over 100 bounced emails, so if you think that you should have a vote and you have not received an email with a voting token yet, please send me an email or leave a comment, I will look up your Maemo username and send you on the voting token/email combo we have on record so that you can vote.
Voting runs until March 30th – you can find more information about the election and the council in the Maemo wiki.
March 15, 2010
community, freesoftware, gnome, guadec, maemo
I just realised this morning that after a very long call for participation period, we’re now in the last week before the call for participation deadline for GUADEC – you should have proposals in by 23:59 UTC on March 20th to be eligible for selection (although a little birdie tells me that might get extended to the end of the weekend). Of course, I knew that the deadline was sometime in the end of March, but I didn’t realise that we’d gotten so far through the calendar!
So get your proposals in about all things GNOME, GNOME 3, GNOME Mobile, usability, accessibility, webability, open data, free services, scaling the community, developer tools, whatever – but get them in quick. It’s better to get a poor proposal in now & improve it next week than wait until next week to polish what you have now.
For guidelines on a good talk proposal, I really like the OSCON guidelines as a list of good dos & don’ts for conference proposals – in general, make the proposal (and your presentation, if accepted) not about you or your project, but about your audience and what they can do with your project – so clearly identify the target audience & why they would attend, and make the title short & action-based, rather than vague, weird or overly clever.
Good luck to teuf and his merry band evaluating all the proposals!
December 24, 2009
community, freesoftware, gnome, maemo, marketing, running, work
Looking back on 2009, I wrote quite a bit on here which I would like to keep and reference for the future.
This is a collection of my blog entries which gave, in my opinion, the most food for thought this year.
Free software business practice
Community dynamics and governance
Software licensing & other legal issues
Other general stuff
Happy Christmas everyone, and have a great 2010.
October 10, 2009
community, freesoftware, General, maemo
Earlier today I gave a lightning talk on giving great presentations at the Maemo Summit. The response has been great, and here are the notes I wrote for the presentation, so that people can refer back tol the advice when the time comes.
Giving Great Presentations
It was said that when Cicero finished speaking, people turned to each other and said “that was a great speech”. But when Demosthenes finished speaking, people said “we must march”.
Throughout history, great orators have changed the world. Entire movements can grow from the powerful communication of an idea.
Yet most technical presentations are horrible. Slides filled with bullet points, and monotone delivery. How many people here have asked themselves at one stage or another during a presentation, “why am I here?”
You might not be Obama, but you can still give better presentations. Here are some basic tips for improving. Nothing I’m going to say here is difficult, but there are no easy fixes either.
Think of your audience
The first tip is for when you are considering giving a presentation, and when you start writing your content. Think of what your audience will get from your presentation. What’s in it for them?
If your point is “to talk about…” you’re off track. You will put your audience to sleep. Seriously.
If you want to share some information, why not just write a blog entry? Why do you need to be in the room?
People don’t care about you. They care about themselves. So make your presentation about them.
A presentation is a sales pitch. You are there to convince people of something. Maybe it’s an idea you want them to believe. Maybe it’s a product you want them to use. If you’re not *selling* something, why are you giving a presentation? You may as well write a blog entry, and stay at home.
So cut to the chase. When you’re thinking about your presentation, think about one core question: What do I want audience members to do once they’ve seen my presentation? And then make sure everything in your presentation is driving towards that goal.
Tell a story
The best way to convince someone of something is to entertain them. And stories are entertaining. Some people are funny, and can use humour to entertain. I’m not funny. But everyone can tell a story.
Human beings are natural storytellers. And stories are a wonderful way to get a point across, especially if you structure your narrative well.
One possible narrative you could use is this:
- Problem statement
- Proposed solution
- Supporting evidence
It’s important to finish your presentation will a call to action. Make people march. The action can be small. Integrate the key lesson of your presentation into their work. Download an SDK and try out some sample apps. Write a letter to a local politician. Donate to your cause.
But make it clear to people what you want from them.
The third suggestion is to design slides to compliment what you say, rather than repeat it.
Don’t write everything you’re going to say on the slide. Otherwise people will just read it, and won’t concentrate on you. You might as well just write a document and stay at home. Bullet points are especially bad for this – avoid them. Slides should be sparse. Pictures work better. Use images that reinforce your point – show, then tell.
Let’s say I wanted to convince you that Ethiopia was once again on the brink of famine. I could show you charts of crop yields, child mortality, and displaced populations. Or I could show you a photo and tell you the rest.
It’s emotional. It’s cheating. It works.
The biggest sin that people make when giving presentations is not to say what they want to say out loud before getting on stage.
Runners train. Football players practice. Musicians and actors spend hours getting performances right. So shouldn’t you too? How do you know how long it will take you to get through your content? How do you know what’s useful and what’s superfluous? Does your presentation have a good flow? Practice will tell you.
Doing all this takes time. It’s not as easy as throwing bullet points together the day before your presentation and hoping for the best.
But think of how many man-hours people will spend watching your presentation. How much of your time is it worth to ensure that your audience isn’t wasting theirs?
So go do it. Concentrate on your audience’s interests. Tell stories and entertain people. Make slides sparse. And prepare beforehand by practising. This is harder than what you do now. The pay-off is huge.
The best part is that your audiences will thank you.
- Really Bad Powerpoint – Seth Godin (source of many of the ideas in this presentation)
- Kill your presentation (before it kills again) – Kathy Sierra – Kathy has lots of material on focusing on your users rather than on yourself – and this is true for presentations too
- Presentation Zen – the great blog of Garr Reynolds – there is an accompanying book which is well worth reading
- slide:ology – Nancy Duarte – one of my favourite books on presentation design – a must-read on all stages of presentation design from deciding what to talk about through to working on your delivery
September 28, 2009
community, freesoftware, General, maemo
After commenting on Mal Minhas’s “cost of non-participation” paper (PDF), I’ve been thinking about the cost of performing a merge back to a baseline, and I think I have something to work with.
First, this might be obvious, but worth stating: Merging a branch which has changed and a branch which has not changed is trivial, and has zero cost.
So merging only has a cost if we have a situation where the two trees concerned with the merge have changed.
We can also make another observation: If we are only adding new function points to a branch, and the mainline branch does not change the API, there is a very small cost to merging (almost zero). There may be some cost if functions with similar names, performing similar functions, have been added to the mainline branch, but we can trivially merge even a large diff if we are not touching any of the baseline code, and only adding new files, objects, or functions.
With that said, let’s get to the nuts & bolts of the analysis:
Let’s say that a code tree has n function points. A vendor takes a branch and makes a series of modifications which affects x function points in the program. The community develops the mainline, and changes y function points in the original program. Both vendor and community add new function points to extend functionality, but we’re assuming that merging these is an almost zero cost.
The probability of conflicts is obviously greater the bigger x and y are. This probability increases very fast the bigger the numbers. Let’s assume that every time that a given function point has been modified by both the vendor and the community that there is a conflict which must be manually resolved (1). If we assume that changes are independently distributed across the codebase (2), we can work out that the probability of at least one conflict is 1 – (n-x)!(n-y)!/n!(n-x-y)! if I haven’t messed up my maths (thanks to derf on #maemo for the help!).
So if we have 20 functions, and one function gets modified on the mainline and another on the vendor branch, we have a 5% chance of a conflict, but if we modify 5 each, the probability goes up to over 80%. This is the same phenomenon which lets you show that if you have 23 people in a room, chances are that at least two of them will share a birthday.
We can also calculate the expected number of conflicts, and thus the expected cost of the merge, if we assume the cost of each of these conflicts is a constant cost C (3). However, the maths to do that is outside the scope of my skillz right now Anyone else care to give it a go & put it in the comments?
We have a bunch of data we can analyse to calculate the cost of merges in quantitative terms (for example, Nokia’s merge of Hildon work from GTK+ 2.6 to 2.10), to estimate C, and of course we can quite easily measure n and y over time from the database of source code we have available to us, so it should be possible to give a very basic estimate metric for cost of merge with the public data.
(1) It’s entirely possible to have automatic merges happen within a single function, and the longer the function, the more likely this is to happen if the patches are short.
(2) A poor assumption, since changes tend to be disproportionately concentrated in a few key functions.
(3) I would guess that the cost is usually proportional to the number of lines in the function, perhaps by the square of the number of lines – resolving a conflict in a 40 line function os probably more than twice as easy as resolving a conflict in an 80 line function. This is slightly at odds with footnote (1), so overall the assumption of constant cost seems reasonable to me.
« Previous Entries Next Entries »