Safe as Milk

Christmas wish: Distro hardware buyer’s guide

December 30, 2009 freesoftware, General 23 Comments

As a long time free software user, every time I buy hardware I have the same decision paralysis. Will the graphics card be fully supported? Are the drivers stable? Will the on-board wifi, sound card, and the built-in webcam Just Work? Will they work if I spend hours hunting down drivers and installing kernel modules (and remembering to reinstall them every time my distro upgrades the kernel)? Or will they stay broken for at least 6 months, until the next version of the OS is released?

I’ve gone through this dance many times in the past – with an Intel 915 graphics chip, and an Nvidia chip before that, with multiple webcams, USB headsets, a scanner, a graphics tablet, digital cameras and sound chips.

Thankfully, problems with digital cameras and sound chips seems to be more or less a thing of the past, except for those USB headsets, but there are still issues with webcams, scanners,tablets and wifi chips. And I keep hearing that support for graphics chips sucks for both ATI and Nvidia, making me wary of both (and thus about 80% of computers on the market).

So when I go shopping for hardware, it sucks to be me. I haven’t tested all this stuff, and I don’t know how much of it works perfectly out of the box. What I need is to decide what software I’m going to put on it, and have hardware recommendations per price point from the software distributor, so that I can just go to my local Surcouf, FNAC or whatever, and just look at one label & say “That’s only 90% supported, no custom from me!”

Does one exist already? I really liked the Samsung NC20 page I found on the Ubuntu wiki, but I would have preferred to see it before buying. The laptop testing team page on Ubuntu is along the lines of what I want, but it doesn’t take a position on any of the hardware, which is what I need. I want Canonical to say “buy this one, it’s great” or “don’t buy that one, unless you’re prepared to spend 2 days messing with drivers”. I know this might piss off some partners, but it’d be really helpful to me. And isn’t that more important?

What I’d like to see is laptops ordered by level of support out-of-box & after fiddling, on the latest version of Ubuntu. So the NC20, for example, would get a 60% “Out of the box” rating (because the video card just doesn’t work at all), and a 90% “after fiddling” rating (because of the CPU frequency issue, lack of support for 3d in graphics driver, and graphics driver instability).

Anyone able to point me to a Linux hardware buyer’s guide that dates from 2009 that gives what I’m looking for?

Side-effects of copyright assignment

December 23, 2009 community, freesoftware, General 1 Comment

Michael Meeks wrote a great piece on the consequences of copyright assignment on free software projects yesterday. He has a lot of experience in the area, and has gone from fervent advocate to something of an outspoken opponent of copyright assignment through his involvement in the OpenOffice.org project in recent years.

One of the things that Michael said in his book is that commercial agreements with partners (resellers and redistributors), made possible by copyright assignment or sharing, can work against the core principles of free software. He cites some examples, but there are many ways that companies use their dominant position within the project:

Vendor X agrees to commercially license their software, on condition that any changes that the licensee makes to the software in the future be submitted only to the vendor. By removing the right to redistribute changes from the licensee, the vendor prevents the licensee from participating in any forks of the project. SugarCRM’s EULA contains a no-forking clause, for example. Ironically, it also contains a “standard” non-reverse-engineering clause, so you may look at the source code before buying the enterprise version to see how it works, but once you are an enterprise customer, that’s off the table.
A vendor ties an official partner programme, support and commercial licensing together. Matt Asay has described the Alfresco parner programme, which contains these restrictions. If you want to be an official Alfresco reseller, you must agree to sell only commercially licensed Alfresco, and you must get the client to commit to a subscription before starting the support contract. You are free not to be an official Alfresco reseller, but in this case, you may not resell commercial licenses for Alfresco, or distribute any commercial add-ons.
No compete clauses can require commercial licensees not only not to contribute to any fork of the vendor’s product, but also to any competitor of the product. While BitKeeper was not a free software product, its licensing agreement contains many of the worst excesses you can find in vendor licenses, to the point where employees of clients were asked to stop working (in their free time) on free software competition.
Proprietary licenses can change under your feet. There are often clauses that allow a vendor to update the licensing agreement at will, and apply it retro-actively to existing clients. BitKeeper did this.
Non-disclosure rules can prevent you from publishing performance tests, for example, as in Alfresco’s trial license. Or even disclosing the terms of your agreement, as Michael suggested, meaning that you can’t even tell people what you may and may not do in the context of the proprietary agreement.

Proprietary software agreements are simply contracts between the vendor and the user, which set out the terms by which both parties agree that the user may use the vendor’s software, and gets some value off the vendor.

Contracts are a part of life. When I rent an office, I have obligations, and so does the landlord. I’m a grown-up and I can agree to whatever I want, if I’m also getting what I need from the deal. But contracts also have victims. As a community member, if you (as a user) sign a contract that says you may not participate in the community, you’re hurting the rest of the community. And if you (as a vendor) force your clients not to participate in the community, or to do so on different terms to everyone else, they you’re hurting the community too.

Since you can only do so much to hurt a community before you don’t have one, this is why I consider copyright assignment a key barrier to entry to community building. And in a vicious circle, because there is little broad community activity around most single-vendor free software projects, those vendors feel vindicated by their copyright assignment decisions, and have little reason to invest heavily in community building – since doing so gives a very low return on investment.

It is possible to build certain types of communities, even with copyright assignment – through a modular architecture which allows anyone to build plug-ins or add-ons, for example, OpenBravo has built a large community of module developers, but has seen little contribution in the core product. And perhaps building a broad and deep group of core contributors is not important to your business model or investors as a company – and that’s fine. The only point I’m making is that you can’t have your cake and eat it. It’s a balancing act between building community and maintaining control.

Running advice

November 23, 2009 General, home 2 Comments

Coincidentally, I was running a 10km race this weekend in Vénissieux, and Chris Blizzard replied to an email about running I sent him months ago. At the time, I gave him a few tips on getting started in running without getting injured, and reading back, I think they are worth sharing.

Advice from a recent beginner

When you start running regularly, take it very easy before you start upping the distance. Your heart & muscles will tell you to go further & faster before your joints are ready for it. Trainers say that you can up your total weekly distance no more than 10% per week. And running more regularly is worth more than running long in fewer sessions. Four three mile runs is better than two six mile runs.

When you do decide to start running further, start doing it in fractions – run 1 mile, walk 1 minute, run 1 mile, walk 1 minute. If you’re on 10 minute per mile pace, that’ll drop you to 11 minutes per mile, but you’ll be able to run 7 or 8 miles easily.

Vary fast & long runs. If you’re starting to stretch out runs & regularly going more than 5 miles in a run, try swapping out one of those 5 mile runs for something like:

Warm up 2 miles
4x800m at a faster pace (if you jog 10 minute miles, then try to run your half-mile split in 4 minutes) with 2 minutes break between splits.
Warm down 1 mile

If you always run long & slow, you’ll stay a slow runner. If you start training your body to run a little faster, you’ll improve the entire system – cardio & muscular. And you sweat more too.

To lose weight, do that 5 or 6 mile run on a Saturday morning – don’t starve yourself the night before, and drink water or tea before your run by all means, but running in the morning on an empty stomach will help you drop those pounds. Once you go over about 30 to 40 minutes running time, you’re eating fat. If you’re diabetic, this might not be advised.

And don’t forget that every body is different, no one scheme or training plan works for everyone. Your body’s a machine, and it’s one which can be made very efficient with maintenance.

Once you get to the stage where you’re running that speed work, you might consider adding some shorter sprints & really start getting faster 😉

Giving Great Presentations – speaker notes

October 10, 2009 community, freesoftware, General, maemo 5 Comments

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
Conclusion

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.

Presentation design

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.

Practice

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.

Garmin Forerunner 405 ANT+ protocol

October 6, 2009 freesoftware, General, running 1 Comment

Anyone anywhere know anyone working for Garmin who might be able to put me in touch with someone who can tell me what the ANT+ communication protocol is, so that I can give it to the good people developing gant, so that they can fix their driver to not crash in the middle of a transfer please? It seems to break for me for any transfer with more than one track.

I can see absolutely no competitive reason to keep the protocol private, it’s almost completely reverse engineered already, and this would cost Garmin essentially nothing, and allow us poor Linux users a way to get our tracks off our watches. The problem is there’s an inertia in keeping this stuff private. It’s hard to get the person with the knowledge (the engineer) and the person with signing power to publish the protocol (a VP probably) in the same place with the person who wants the information (little ol’ me) – it can take hours of justifications & emails & meetings… Can anyone help short-curcuit the problem by helping me get the name of the engineer & the manager involved?

Thanks!

Estimating merge costs

September 28, 2009 community, freesoftware, General, maemo 2 Comments

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.

Footnotes:

(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.

The value of engagement

September 17, 2009 community, freesoftware, General, gimp, gnome, maemo, work 5 Comments

(Reposted from Neary Consulting)

Mal Minhas of the LiMo Foundation announced and presented a white paper at OSiM World called “Mobile Open Source Economic Analysis” (PDF link). Mal argues that by forking off a version of a free software component to adjust it to your needs, run intensive QA, and ship it in a device (a process which can take up to 2 years), you are leaving money on the table, by way of what he calls “unleveraged potential” – you don’t benefit from all of the features and bug fixes which have gone into the software since you forked off it.

While this is true, it is also not the whole story. Trying to build a rock-solid software platform on shifting sands is not easy. Many projects do not commit to regular stable releases of their software. In the not too distant past, the FFMpeg project, universally shipped in Linux distributions, had never had a stable or unstable release. The GIMP went from version 1.2.0 in December 1999 to 2.0.0 in March 2004 in unstable mode, with only bug-fix releases on the 1.2 series.

In these circumstances, getting both the stability your customers need, and the latest & greatest features, is not easy. Time-based releases, pioneered by the GNOME project in 2001, and now almost universally followed by major free software projects, mitigate this. They give you periodic sync points where you can get software which meets a certain standard of feature stability and robustness. But no software release is bug-free, and this is true for both free and proprietary software. In the Mythical Man-Month, Fred Brooks described the difficulties of system integration, and estimated that 25% of the time in a project would be spent integrating and testing relationships between components which had already been planned, written and debugged. Building a system or a Linux distribution, then, takes a lot longer than just throwing the latest stable version of every project together and hoping it all works.

By participating actively in the QA process of the project leading up to the release, and by maintaining automated test suites and continuous integration, you can mitigate the effects of both the shifting sands of unstable development versions and reduce the integration overhead once you have a stable release. At some stage, you must draw a line in the sand, and start preparing for a release. In the GNOME project, we have a progressive freezing of modules, progressively freezing the API & ABI of the platform, the features to be included in existing modules, new module proposals, strings and user interface changes, before finally we have a complete code freeze pre-release. Similarly, distributors decide early what versions of components they will include on their platforms, and while occasional slippages may be tolerated, moving to a new major version of a major component of the platform would cause integration testing to return more or less to zero – the overhead is enormous.

The difficulty, then, is what to do once this line is drawn. Serious bugs will be fixed in the stable branch, and they can be merged into your platform easily. But what about features you develop to solve problems specific to your device? Typically, free software projects expect new features to be built and tested on the unstable branch, but you are building your platform on the stable version. You have three choices at this point, none pleasant – never merge, merge later, or merge now:

Develop the feature you want on your copy of the stable branch, resulting in a delta which will be unique to your code-base, which you will have to maintain separately forever. In addition, if you want to benefit from the features and bug fixes added to later versions of the component, you will incur the cost of merging your changes into the latest version, a non-negigible amount of time.
Once you have released your product and your team has more time, propose the features you have worked on piecemeal to the upstream project, for inclusion in the next stable version. This solution has many issues:
- If the period is long enough, your feature additions will be long removed from the codebase as it has evolved, and merging your changes into the latest unstable tree will be a major task
- You may be redundantly solving problems that the community has already addressed, in a different or incompatible way.
- Feature requests may need substantial re-writing to meet community standards. This problem is doubly so if you have not consulted the community before developing the feature, to see how it might best be integrated.
- In the worst case, you may have built a lot of software on an API which is only present in your copy of the component’s source tree, and if your features are rejected, you are stuck maintaining the component, or re-writing substantial amounts of code to work with upstream.
Develop your feature on the unstable branch of the project, submit it for inclusion (with the overhead that implies), and back-port the feature to your stable branch once included. This guarantees a smaller delta from the next stable version to your branch, and ensures you work gets upstream as soon as possible, but adds a time & labour overhead to the creation of your software platform

In all of these situations there is a cost. The time & effort of developing software within the community and back-porting, the maintenance cost (and related unleveraged potential) to maintaining your own branch of a major component, and the huge cost of integrating a large delta back to the community-maintained version many months after the code has been written.

Intuitively, it feels like the long-term cheapest solution is to develop, where possible, features in the community-maintained unstable branch, and back-port them to your stable tree when you are finished. While this might be nice in an ideal world, feature proposals have taken literally years to get to the point where they have been accepted into the Linux kernel, and you have a product to ship – sometimes the only choice you have is to maintain the feature yourself out-of-tree, as Robert Love did for over a year with inotify.

While addressing the raw value of the code produced by the community in the interim, Mal does not quantify the costs associated with these options. Indeed, it is difficult to do so. In some cases, there is not only a cost in terms of time & effort, but also in terms of goodwill and standing of your engineers within the community – this is the type of cost which it is very hard to put a dollar value on. I would like to see a way to do so, though, and I think that it would be possible to quantify, for example, the community overhead (as a mean) by looking at the average time for patch acceptance and/or number of lines modified from intial proposal to final mainline merge.

Anyone have any other thoughts on ways you could measure the cost of maintaining a big diff, or the cost of merging a lot of code?

Six word novels

August 4, 2009 General 20 Comments

I happened on a Wired article about the 6 word novel this morning, in a link from a newsletter I’m subscribed to.

Like Haiku and other very formulaic structures, the six word novel gives the author enormous freedom while constraining them in a fish-bowl.

My favourite examples:

“For sale: Baby shoes. Never worn.” – Ernest Hemmingway.
“Longed for him. Got him. Shit.” – Margaret Atwood
“With bloody hands, I say good-bye.” – Frank Miller

Reading these, and seeing the second-place finisher of the competition in this newsletter (which was my favourite): “My secret discovered. Plane ticket purchased.” made me want to give it a try.

After some work, here’s my best effort.

As the noose tightened, she remembered.

A bit macabre, nonetheless I’m pretty happy with the images it brings forward, and the questions it leaves unanswered.

Anyone else care to try?

GCDS round-up 4: Days 2 – 4

July 30, 2009 General, gnome, guadec, maemo 2 Comments

Sunday, Monday and Tuesday were the “core” days of the Gran Canaria Desktop Summit, with cross-desktop and KDE & GNOME specific presentations throughout. I caught a number of presentations, but mostly I was chatting in the hallway track, or doing work on the schedule, or actually working.

For me, the story of the 3 days was “parties”. I missed the early sessions on Sunday and Monday to get breakfast at 10am, after the parties hosted by Nokia (Sunday night) and Igalia (Monday night) – I was relieved that there was no party planned on Tuesday night, my 35 year old body couldn’t stand the pace! Great parties, not marred by excessive boozing mostly, and some great chats, notably with jrb, and Adam Dingle and Jim Nelson from Yorba, makers of Shotwell, a Vala photo manager with some really nice features and plans. And some great discussions with Michael Meeks and Matthew Garrett on the fouton during the Igalia party, with Federico Mena Quintero on architecture design patterns, and Jorge Castro on dinosaurs. I also got to meet Joaquim from Igalia, the Macacque band were great, but I’m sure that a hoarse Lefty regretted sweet home chicago and smoke on the water the day after.

I did get to some presentations though (here with a one line summary):

Power management by Matthew Garrett: “Power management isn’t doing the same amount of work, slower. Do less work, or you’re killing polar bears.”
ConnMan by Not Marcel Holtmann (Joshua Lock from Intel gave the talk in the end – thanks Emmanuele!): “ConnMan solves some problems for Moblin that NetworkManager wasn’t designed to solve.” (I think).
Bluetooth on Linux by Bastien Nocera: “It mostly works now”
Introduction to GNOME Shell, by Owen Taylor: “It’s pretty cool stuff already”
GNOME Zeitgeist, by Thorsten, Seif and Federico: “We record what you’re doing”
Communicating design in development, by Celeste Lyn Paul: “Keep it simple until they get the design principle, excessive realism too early just makes the discussion about the details”. Unfortunately, I don’t see a video available, highly recommended viewing if there was one.
GNOME 3.0: A live circus^Wstatus update, by Vincent Untz et al: “It’s not just GTK+, Zeitgeist and GNOME Shell”
GNOME 1,2,3, by Fernando Herrera and Xan Lopez: “A history of GNOME with thanks to YouTube” (my favourite presentation of the conference)
Personal Passion lightning talks, by Aaron Bockover: “We’re not just Free Software hackers!” This was absolutely my second favourite session of the conference. We got a 10 minute overview of the burnout cycle from Jono Bacon, underlining how important it is to have a life outside of software, and heard from people whose passion was running (complete with a soundtrack of me finishing a marathon), airplanes, motorcycling, cooking, bacon, dinosaurs, Aikido, buddhism and calligraphy, trekking in Argentina, and also a couple of geeky ones on icon design and scheme (which was very enjoyable indeed, thanks Andy!)

Update: Memory playing tricks with me – for of course, Tuesday evening was the highly anticipated meeting of SMASHED. We finally met at the Mare Baja again, where the opening night party was held, and enjoyed a bunch of tapas courtesy of CodeThink, before scoffing down some great whisk[e]y, including (from memory) a 21yo Highland Park, a nice 16yo Longmorn, a very lod bottle of Oude Ginever from Lefty, an old standard Connemara single malt, and a Yamazaki 10yo I brought.

SMASHED 2009 in Gran Canaria

Festivities carried on until after 1pm, when I left with Andrew Savory and someone else (whose name I don’t recall), and Behdad got in an unprovoked fight with the footpath on the way back to the hotel – it came right up and hit him in the face. Some nice KDE people took him to the hospital to get sewn up – luckily the group photos had been taken earlier in the day.

Got back to the hotel around 2, and tried to catch up on some of that beauty sleep before Mobile Day on Wednesday in the new conference location in the university.

Last minute schedule change: Personal passions

July 7, 2009 General, gnome, guadec 1 Comment

I was talking with Aaron Bockover yesterday and he told me that he wasn’t going to give the Silverlight talk which he had submitted back in March, and that he planned to give a presentation on something completely unrelated that he found interesting. Chris Blizzard suggested that he could give a lightning talk on amateur aeronautics, and as the idea spread a whole bunch of ideas on interesting non-GNOME related subjects that GNOME community members are interested in came up from architecture to running. There’s also a really valuable short talk on the burnout cycle (and how to break it) from Jono Bacon in there. So for 45 minutes, we will have a set of lightning talks reflecting the eclectic nature of the GNOME community – if you see Aaron and have something you are passionate about that you want to talk about for 3 to 5 minutes, grab him today or turn up at his session at 5:30 and shout.

And spread the word!

« Previous Entries Next Entries »