I was speaking to a friend the other day who is very connected with the open-source software world, and she effectively labelled the whole process of licensing software as “wrong”. Unethical, I guess, was her point.

This is not something new as anyone who’s read Richard Stallman or countless other open-source manifestos and stories knows. However, I guess I’ve never thought about it on a personal level. I own a software company that has built a piece of software over the past five years. We license this software to our customers, often on a monthly rental basis, or a traditional purchase plus annual license agreement. Am I being unethical? Am I conducting business in some morally corrupt way?

My friend Bendrix would no dout just say something rude and dismissive about morality as a concept. But it’s not actually that simple, of course. I do actually care to try and operate in an ethical way, and so does Cambrient. I think we’d all be pretty horrified if we thought what we were doing ranked along with putting horses heads in people’s beds.

So, my friend’s points were, in essence:

1. We are creating absolute vendor lock-in: because what we’re selling clients are solutions based entirely on our product, the client can never leave us with their system. If they go — even if we hand over the bits of code we’ve written especially for them — they are left with nothing after spending a whole pile of money with us.

2. Open source software enables anyone to pick up the code where it was left off by a previous developer, and keep working. And so the purchaser has absolute confidence that whatever they invest their money in now can never be without value.

I have to stop and think about this, because I guess I agree in broad terms with the spirit of this stuff. As a business, why pay someone to build you something you cannot own or operate in their absence? Would I build a house which required the developer to be constantly paid in order to keep the house standing. If I stop paying, the house falls over.

This kind of analogy only really goes so far though. And here, in essence, is why I don’t think licensing software is unethical.

1. Custom code is pretty much always without inherent value. Even a thoroughly documented system is incredibly difficult for a new programmer to take over, maintain and extend. Why? Because there are many, many different ways to approach ever piece of software development. In many ways, programming is like writing music. There are an inifinite number of different ways to write a symphony. Ask another composer to write a new passage into Beethoven’s 9th and chances are he’ll screw it up.

Or, worse, it’ll take him so long and be so much trouble that he’d have gained better results by starting over. And that’s the same with software.

Unless a system is so huge and so complex that writing it again isn’t an option, it’s almost always cheaper to start again than to take over code from someone else. Even if it’s well documented, and that’s a big if. Open Source systems are, in fact, notoriously poorly documented. Commercial source code often lacks documentation altogether.

What a client is therefore paying for, I believe, is not the code. It’s the process, the customer service and the ingenuity of that programming team. Plus, of course, the commitment to get a working solution in place. The code is a means to an end, not the end in itself.

2. Even when you build on an open source product, the work that gets added to it is custom code. It’s specific, proprietary and obeys the same laws of programmer styling as mentioned above.

So, what are the ethical guidelines for selling software?

– Honesty about lock-in upfront. We are always honest about this. However, larger product-only vendors (say Microsoft to pick an easy target) will argue that by picking them you can easily migrate to other developers should your current team not work out. And without having to throw away your work. This is nonsense for exactly the reasons above.

– A solid contract governing the ending of your relationship: say we go bankrupt, or we screw up the job, or you hate us because we ran over your cat. The ownership and use of code must be clearly governed in an agreement. This is far more important than mere code ownership. I could give my clients our source code tomorrow (won’t, but could) and it would be of absolutely no value to them. However, if I gave them usage rights over the system if our relationship ends, along with a contraced handover to another development company of the custom parts, suddenly it is useful.

– Focus on the right parts of the risk: it’s actully irrelevant who owns what. What matters is the relationship. Unlike a house, a software system is never finished. Operating systems change, browsers change, hardware changes. And requirements change. No matter how you look at it, building a software system is getting into a long-term relationship with your development partner. The risk is not ownership, it’s the partner you pick. So that’s where the effort should be placed in negotiation. Believe me, if the relationship ends, you have much bigger problems than who owns the system.

In all the years I’ve been involved in software, I’ve only once seen a client arrive with a system on a CD and ask us to take it over. We agreed, and within 6 months we had started again and rewritten the whole system. That vendor who was acting “ethically” in my friend’s view did not place the company in any better a position than if they’d retained ownership of the code. In fact, they were misled more by believing they owned something they actually didn’t.

On reflecting on all this, I sleep easy at night because of one thing: I’m honest with my clients about what they’re getting. I absolutely abhor the idea that people are sold something they then later discover to be a fiction. It gives the whole software industry a bad name. Honesty, not freedom, is the world’s rarest commodity.