Anyway that’s not really the point.  I used to be a nearly full-blown freetard a long time ago.  I had the whole ‘hate the man’ thing down (Microsoft) and bought into the whole ‘by developers, for developers, lets cut out the corporate middle man’ movement.  This was before I had even really used Linux – but the concept seemed sound.  And how can a developer not fall for that idea – software utopia, plus never having to deal with anti-user crap like artificial limits and activation again!  But then I actually used it for an extended duration and moved into my ‘the idea is sound, but it just needs more work’ phase.  I believed with the concerted effort of like-minded people and by including designers, UI experts and artists it was only a matter of time.  The third phase was that it was a shame that a great idea was being ruined by a defensive community of non-developer, non-contributing idiots intent on scaring away anyone who didn’t believe it was already perfect.  At least I was partially right that time.

And finally, I am where I am now: It’s a bad idea to the point of being dangerous and it just won’t work anyhow.

Here’s the thing.  Nobody owns GPL’d code.  The code is free.  You are not.  For example you, as a user, have more freedoms when it comes to BSD licensed code – effectively you can do what you want with it, provided you provide credit.  GPL’d code on the other hand has a slew of limitations on what you can and cannot do and attaches a larger burden on you in terms of distribution of changes and source.  The code is more ‘free’ under the GPL.  By GPL’ing code you effectively say ‘nobody owns this, it belongs to itself’.  I can sell BSD code and deny you your ‘fundamental right’ to freely distribute it further.  I can also grant you the same right as the GPL.  The GPL simply ensures you cannot stop anyone from modifying and distributing.

The problem with the above is that it entirely negates ownership.  You cannot ‘own’ free software.  It doesn’t matter if you wrote it – it’s not yours.  As soon as you release software under the GPL you have no more right to it than any of the other 6 billion people on the planet.  It’s why FOSS advocates call closed source (distastefully) ‘slavery’, as closed source software is owned and controlled by someone.

The ramifications of this are obvious – you can’t make money selling free software.  You can sell it, but so can everyone.  If you’ll need to sell 10,000 copies at £100 each to reclaim your investment and the kid in the local computer store will sell them for £5 to anyone that wants one then you’re simply never going to break even.  The whole ‘you can sell free software’ excuse is intellectually dishonest as you have to compete with people with no sunk or running costs.  The best you can do is put up an online tip-jar and rely on effectively begging – and I’ve yet to hear of that working well.

Effectively, what the GPL and the Free Software movement says, is that developers do not deserve to be compensated for their effort.  Unless they can manage to sell the first copy for £1,000,000 then there is no way to ever get paid for the time spent.  It simply can’t be done.  If you want to man a phone line, do email support, work as a call out technician, then you can (according to ‘software freedom’) demand a fair hourly wage, but if you are a developer you can’t.  It’s ‘immoral’.  Simply on the basis that you cannot own code, thus can’t charge money for it.

The argument often made about the above is that businesses still need programmers.  Which is true.  But this is where the whole thing unravels fully.  I am a programmer – say I have an idea for a great new CMS tool*.  I now have two options:

1. Quit my job, rely on my family to put up with me for a few months while I spend 12hrs+ a day working on it.
2. Take my idea to a large company such as IBM, Oracle, Microsoft or someone else like that.

As above, according to the ‘software freedom’ camp if I picked option 1. as soon as I released it it would be mine no more.  The second I tried to charge money for it it would just be forked and given away.  Instead of relying on the future income I could have gained from selling it at launch to pay back the debts I would have no doubt incurred, and to fund new development, I would be forced to ‘get a job’.  Any development work would have to be done in evenings and weekends – and I would effectively be forced to decide between programming what I want, or my marriage.  Plus the software would progress more slowly as I would not have much time to devote to it.

Now with option 2. there is pretty much zero chance of getting taken up on my idea.  You don’t tell a business that you want to hire you what you are going to work on.  Unless you are really, really famous.  Chances are unless your surname is something like ‘Carmack’ you’re going to be writing the mundane stuff that they want you to do – not your own exciting ideas.

There are companies that are based around and heavily involved in free software.  Names include companies such as Red Hat, Mozilla, IBM, Canonical, Google, Novell etc and the one thing about these companies is that they are not in the software sales business.  Red Hat is in providing support and SLA’s for businesses and servers. IBM is similar to Red Hat – they sell ‘solutions’.  Mozilla makes money from advertising for Google, Canonical is a billionaire’s plaything, Google sells advertising and Novell is just a slightly more pragmatic Red Hat.  You’ll never see a company such as Adobe adopt a FOSS business model as they are in the business of selling software.  I don’t imagine anyone can make the argument that Adobe can go FOSS and remain profitable with a straight face.

It’s the following realisation that made me realise what a disaster FOSS really is.  Free Software only benefits large companies and the rich.  It is almost impossible to be a developer and not work for ‘the man’ under the GPL.  Sure there are exceptions to every rule but the simple fact is you can’t be a developer unless you can get an alternate revenue stream.  Support is good, but not a lot of apps will require support and you don’t spend months programming to be forced to make money manning a phone line.  There are also the dual license options, but this is effectively shareware, and you are still making money selling closed source software.

If adhering to the GPL was a legal requirement then it’s not like software would all suddenly be free and open.  What would actually happen is that people would simply stop making software.  All the games available on Steam would not suddenly be free – they simply wouldn’t have been made in the first place.  I pay money for SmartFTP because it is the best FTP program I have ever used.  By paying money I help fund further development.  I am happy with this.

It’s not even like the mass piracy and commoditization of  music, as it’s not like developers can make money selling tickets at £50 a go to live shows.  The software itself is all you’ve got.

Now I simply don’t see how anyone who thinks pragmatically about a future in which the GPL is accepted as the way to distribute software can possibly support it as in reality the people it hurts the most are the very people that support it – individual developers.

* True story, I do.  I am working on it and plan to launch it in a few months.

Some Further Thoughts and Ugly Truths:

The most overlooked point with regards to software development is that it is generally the result of a few people sinking a large amount of time into it, not as a result of a lot of people doing a small bit.  You simply can’t throw developers at a project and expect it to flourish – it just doesn’t work.  If you want something well written and cohesive it’ll take a small, dedicated, team – not a large bunch of semi-skilled volunteers – not something that really happens in FOSS unless you are being funded by a rich 3rd party.

Capitalism, in a nutshell, is providing people what they want.  If you don’t provide it you don’t succeed.  If enough people don’t want it the provider can either improve and adapt, or die.  In the FOSS world you take what you’re given and have no right to complain.  Gimp is near useless and doesn’t even match the decade old Photoshop 5.0 yet people not using it will not spur on development.  There is simply no motivation to cater for a wide audience – if Gimp was a commercial product the company would have been bankrupt years ago but catering for your users needs is simply not important in the world of free software.  Free software is about developers scratching their own itch, not finding out what itch other people want scratched.

The bulk of FOSS development work is done by one of these people:

• Students, getting paid to learn.
• Unemployed, getting paid by the state.
• The Rich, resting on their laurels.
• Large companies, adding value to their other services.

Free software is categorically not made by these people:

• Software companies.

If it is name one.

Software development is hard.  It’s incredibly time consuming.  If most people truly appreciated the difficulty and time required to create a truly great piece of software I doubt they would have bothered.  It requires people with a true passion for development to make truly great software, and I personally find the fact that such people would be relegated to only doing what they love in their spare time, rather than as an actual job, disgusting.

And finally it is the software that is free, not you.  All this talk of ‘freedoms’ and ‘rights’ is utter crap – it’s not your freedom or your rights so the whole idea that commercial software is taking them is simply untrue.  If a developer wants to release something under a Libre license that is fine – but it should never be considered ‘ethical’ or expected for this to be the case and if you really want to make a case for your own ‘freedoms’ then the BSD license is far more appropriate candidate.

Open Source is simply providing software with the source code so the receiving user can modify it to suit their needs.

Free Software is having the ability to freely modify and (this is the key) distribute software they have received from a 3rd party.

Free Software is being *unable* to restrict what a 3rd party does with your software.

You can very easily have non-free Open Source.  In fact a large amount of software made, mainly custom stuff and most of what I do, is technically ‘Open Source’ – that is I am paid to to do it, and I give the client the source along with any binaries.  It is *not* Free Software though, as the client is unlikely to give it away.

For example a large amount of commercial web apps are Open Source in that you have access to the source code, but are not Free Software as you do not have the right to redistribute the source freely.

This is the main bone of contention between the Commercial and Free Software camps – it has nothing to do with source – which is a red herring – it has to do with control.  The main point of free software is to remove any and all control from the original developers and give it to the users – the software is owned by the community.  Supporters of the commercial model (obviously) have a problem with this as it makes making a business out of developing software impossible – If you sell support you are in the business of support, not software.  Free Software is fundamentally anti developer.

Personally I support Open Source, and plan on releasing my next project as a dual licensed Free Non-Commercial and pay for Commercial offerings.  You can use it for free and give it away if you do not use it commercially, and if you want to use it commercially you will be required to pay a license fee.  Which is perfectly reasonable but it is not ‘Free Software’ and would not be supported by the FSF.

Free Software is an ethical line for it’s supporters.  Non-free (as the example above) is considered immoral by supporters and according to the FSF I am unethical in my request for compensation for commercial usage.  According to the FSF doctrine I must relinquish all ownership over the code and give any user full source and distribution rights.  If I want to make money I should sell ‘support’.

The thing is if (and many people suggest this) I was legally forced to make it ‘Free’ I would not even bother to make it in the first place.  In that world the job of ‘developer’ either would not exist, or would be relegated to a role in a huge corporation where you are told what to work on.  The small, independent software companies would be dead – and the software that they would have produced would not now be free, it just wouldn’t exist in the first place.  So instead of having the choice to pay money for something or not have it, you’d simply not be able to have it at all.  Not a situation I can support.

I think if people stopped thinking Free Software and Open Source are interchangeable terms, and that if more people found out what Free Software really is, and the implications, significantly less people would support it.

Update: I do not think that Free Software is bad, should be banned, or anything like that.  I believe it is up to the developer to choose how to distribute their software and that there is nothing wrong with closed source, commercial software.  It is up to the developer to choose the license, and the user to choose the software.  It’s all about choice.

Find me three examples of constructive criticism of Linux on a public, semi mainstream Linux forum that…

1. Isn’t a flamewar
2. That the answers are not all largely YouDontNeedThat ™ and
3. The developers of the software actually read.

Linux sucks.  All your showcase apps such – Gimp, Cinerella, OpenOffice, etc suck, Your WM’s are bad copies of the commerical offerings, your API’s and interfaces are so slow and convoluted it’s quicker to run Firefox under Wine that it is natively and apart from everything crashing a bit less and hibernate/sleep allegedly working on some peoples computers nothing has changed in over a decade.

Linux has < 1% of the marketshare and is dropping.  In fact it’s marketshare is within the statistical margin of error – the reason companies don’t rush to support you is because it’s simply not economical – not some large conspiracy.  Why is this – it’s certainly not because of the popularly claimed reason ‘poor marketing’, as its pretty much impossible to go anywhere on the net without meeting evangelical freetards.  Yet people, despite knowing about it – and even trying it! – are failing to use it in droves.

It simply isn’t good enough, and has too many problems.  I, as a professional software developer, don’t use it.  And the big problem, the #1 reason Linux sucks is this:

You don’t want to know why I don’t use it.

I could spend hours going into the specific reasons that it doesn’t fill my needs, problems I have, even giving examples and ideas on how to improve things, better approaches etc.  But it would be pointless – I’d just be called a MS shill.

My first real foray into Linux was when I was running an Internet Cafe, and had heard so much about how fantastic it was, years ahead, stable, etc – you all know the talking points.  This was around 2006 iirc.  So I set up a test box to see how it fared.  Not very well was the answer – not only did I hate it, my customers did too.  So since I’d heard so much about community contributions I wrote up a long article on what I felt the limiting factors for both me and my customers were.  I was willing to even learn C at that point and help contribute.

And rather than do what a professional software development team would do and take these suggestions on board – which included classics such as ‘What about a bootsplash, verbose mode is scaring the customers’, I had idiot newbies such as the aforementioned Thomas B ‘debunking’ me.  I was called an idiot for wanting double clickable .deb files (don’t you know apt-get install is easier?).

Linux zealots are on an ideological crusade, and the few that aren’t idiots spend little to no effort reining in the freetards – and it is impossible to argue with idiots, as they drag you down to their level then beat you with experience.  Since they are promoting the concept of free software they don’t really care if it’s better or not – quality is judged by the release license, not the code.  As a result criticism of Linux is seen as criticism of the Ideology – and attacked.  It’d be like advocating grilled steaks on a vegan forum, which is fine – I am vegetarian myself – but they seem to think that everyone else should care about their bizarre concept of ‘software ethics’ as much as them, when most people don’t care – they just want the tastiest food, and the best OS.

So the situation is this:

You’ve got distro’s that release the software, and due to package management, are the intermediary between the users and the developers.  Since the distro’s largely just package up and send on other peoples work they generally don’t even have any form of feedback method outside bugzilla.  Add to this the fact that the community is actively hostile to anyone who happens to disagree with them and you have a real recipe for stagnation.

The reason Linux sucks is because the developers are shielded from any criticism by the fan(boys|base) and by the time that they do hear from someone they regularly have become so pissed off and disappointed with the whole experience that they just declare ‘it sucks’ and are rarely constructive.  Personally I am in that state half the time.

The other problem with the community is that they are largely all of the same opinion (Linux rocks, Micro$oft sucks, viva la Stallman!) not because they are right, but because everyone that disagrees with them has left.  It’s a monoculture which simply isn’t healthy as nobody is willing to accept having their ideas challenged.

After all how on earth can you ever expect to improve anything if you kick out all the people who think it can be improved?

If I am wrong, then surely the above challenge should be a piece of cake, five minutes, just pop over to any large distro’s forum.  So go ahead, what are you waiting for, prove me wrong!

Addendum:

I was just having a look through Wikipedia and found this really interesting article on Groupthink.  Especially this bit:

To make groupthink testable, Irving Janis devised eight symptoms indicative of groupthink (1977).

1. Illusions of invulnerability creating excessive optimism and encouraging risk taking.
2. Rationalising warnings that might challenge the group’s assumptions.
3. Unquestioned belief in the morality of the group, causing members to ignore the consequences of their actions.
4. Stereotyping those who are opposed to the group as weak, evil, biased, spiteful, disfigured, impotent, or stupid.
5. Direct pressure to conform placed on any member who questions the group, couched in terms of “disloyalty”.
6. Self censorship of ideas that deviate from the apparent group consensus.
7. Illusions of unanimity among group members, silence is viewed as agreement.
8. Mindguards — self-appointed members who shield the group from dissenting information.

Groupthink, resulting from the symptoms listed above, results in defective decision making. That is, consensus-driven decisions are the result of the following practices of groupthinking^[5]

1. Incomplete survey of alternatives
2. Incomplete survey of objectives
3. Failure to examine risks of preferred choice
4. Failure to reevaluate previously rejected alternatives
5. Poor information search
6. Selection bias in collecting information
7. Failure to work out contingency plans.

Sounds like the Linux community to a tee, doesn’t it?

After it hit the App store, one of the original developers of XPilot told us he feels adamantly that we’re betraying the spirit of the GPL by charging for it.”

Firstly, it’s very hard to ‘betray the spirit’ of a license.  That’s why you have a license in the first place.  If it’s written by anyone even half competent they will check for loopholes and problems.  Hence the GPLv3 in response to TiVo.

What actually happened though is the original developers GPL’d it after listening to the hippy ‘power of the community’ love fest with no real understanding of the implications.  Which is this:

It gives freedom to the software, not the developer.  It is the software that is free.  You develop software, fine.  Release it under the GPL, fine.  But you no longer own it.  You have no more rights than anyone else to it.  By releasing under the GPL you explicitly relinquish all of your control over it.  You have freed it like you would free a bird from a cage – it is yours no longer.

It is amazing how so many people fail to understand this.  The whole ‘you can sell it’ thing is a red herring as piracy is legally enshrined in the license – everyone else can sell it too as proven by this.  There is nothing stopping me recompiling it and putting it on the app store for $0.50, or even for free.

What the XPilot creators actually wanted was one of the Creative Commons licenses (maybe NC-3) as that would appear to be what they think the ‘spirit’ of the GPL is.

The amusing thing in all of this is not only do normal users not bother to read their license agreements (EULA), but apparently neither do the developers of the software either.

You hear it all the time “Free as in beer” and “Free as in freedom” used to describe FOSS.  But this question seems to be missed:

“Where can I get free beer?”

No pub will just give it to me, if someone buys me one I am expected to buy them one back at some point.  I could brew my own but I still need to buy all the equipment and spend a lot of time and money.  Guess what?

“There is no such thing as free beer!”

I get the whole “Free as in freedom” thing, I really do.  In an age of excessive DRM and activation the ability to have access to the source is incredibly useful.  As a developer dealing with PHP on a regular basis I am often stumped by ‘compiled’ PHP which makes a problem a customer is having impossible to fix as the original developers do not give their customers permission to fix their own problems.

It’s this whole “Free as in beer” craze that makes utterly no sense.  Name me any other discipline where you expect to get anything for free.  Architects will not design you a free house, Lawyers will not defend you for free (unless it is in their best interests), People will not wash your car, house, clothes or computer for free.  And pretty much nobody will fix your computer for free.  Yet is expected and even considered immoral to charge money for software!*

Developing software is hard.  It takes a ridiculous amount of time and effort – I should know, I do it full time.  Yet Under the FOSS regime I am expected to work for months on producing something then not only provide the source with the product (which I can accept and often do), but to also give away every single one of my rights as its creator, giving me no more ownership or rights over it than any random yahoo off of the street?

And the FOSS solution to this?  Sell ‘support’.  What?  So as the softwares creator, to recoup the months of investment I need to provide bottom rung email and phone support which I wouldn’t even do if I was paid.  I would rather be unemployed than tech support, yet in the FOSS world that is my only option to even consider recouping my investment if I decided to have a career in software development.

“But big companies support FOSS”

Fantastic! Instead of working on what I want to work on, and creating innovative software that I think will fill a niche which I will then sell to make money to fund further development, I should instead go to work for IBM who will tell me what to write if they even hire me at all?  That doesn’t sound like any freedom I have ever heard of – it sounds like being a wage slave to enrich a large corporation.  “Free as in freedom to work for IBM”, but not “Free as in freedom to write your own software”.

“But Linux Torvalds wasn’t supported by IBM”

There are two types of FOSS projects:

1. Spoilers:
   Commercial software companies that realise their pay-for software is largely no longer saleable – Mozilla, Sun, OpenOffice etc.  It’s normal, conventional, closed source software that was ‘opened’ in response to the market.  You can’t sell browsers anymore (see Opera) so you need to either give up, or find alternate revenue.  Firefox makes its money from Google, OpenOffice is crap compared to MS Office and is given away in an attempt to provide value to the systems it’s given away on – and also as a ‘fuck you’ to Microsoft.
2. Students:
   The bulk of the non-commercially contributed FOSS code is made by students.  That is people that are being funded externally to learn about computers and use their knowledge, resources and free time to create ‘free’ software.  Obviously they largely don’t want to sell it as then they will have to deal with large amounts of problems (including actually finishing it) and it’s fun to create it, not a job. By giving it away free rather than charging they are not beholden to their customers for quality or bugs.  “Fix it yourself” is the mantra of the student developers.
   

There is one, very notable, absence from this list:

• Conventional, small, development shops working on producing free software full time – that is the non-corporate, individual development house.  They are the one business that simply cannot survive under the FOSS model, which is ironic as it’s probably the best situation to be in as a programmer.

Lets face it here, you can’t make money writing FOSS software.  You can use it to assist in an aspect of your multi-faceted business as, in theory, community contributions will improve your software for free – If I run a business selling special widgets and make a FOSS special widget tracker, then other people selling these special widgets would improve the software if they used it also so I (and my business) would benefit from it.

What FOSS does not allow is for someone to say “Aha!  There is a market for software for companies selling special widgets, I’ll make some.” – your going to be able to sell a few at best before someone takes your code, rebrands it and gives it away.  You essentially have to compete with yourself.

This is the point where some FOSS advocates offer up other ways of monetizing my Special Widgets software – Selling support (bleh), customizing for individual businesses, support contracts (bleh).  But what they are asking for is for me to dump a business model that has worked for thousands of years – you give me something, I give you something in return – and instead adopt an entirely unproven method of “you give me nothing, I give you something in return and then try to figure out how to make money at a later date.”

Why should I have to dump a perfectly functional business model to adopt something incredibly uncertain and very likely to make me bankrupt simply because some idiots on a crusade say I should?

Whats really needed is the ability to decouple this moronic notion of ‘Free as in beer’ from ‘Free as in freedom’, as unless everyone, including butchers, bakers and candlestick makers also give everything away for free** then it’s just not going to work.

* Yes, I know you can sell software for money according to the GPL.  What everyone loves to gloss over is the fact that anyone you sell it to can just give it away for free – so you will very soon be competing against your own product, but free.  The GPL is fundamentally incompatible with conventional for-profit software sales.  There are some choice early RMS quotes where he basically says this – the only reason for-profit sales are allowed is that they are unworkable.

** Yes, it’s been tried, no, it hasn’t ever worked and yes, it’s called ‘communism’.

Fortunately, although voluminous, there is very little actually said.  So I’d like to summarise why he’s wrong in three statements.

1. A logical fallacy will not suddenly become truth if you provide two pages of analogies.
2. An outright wrong statement will not turn correct if you provide two pages of examples.
3. Those that shout the loudest have the most to hide.

And onwards…

3: Those that shout the loudest have the most to hide. (Start at the end)

So lets deal with 3. first.  This is hilarious, and cements my argument for the rest of this post.  Check it out:

1. Go to the aforementioned article
2. Click view->page source
3. Read and chuckle

Firstly, the whole page is generated – whoever made it knows zero about HTML and web development though – that much is clear, as proven by such gems as:

<b><span style=""></span></b><span style=""></span>

Bold, styled nothing. Which is the obvious result of a confused WYSIWYG editor.  And not even a good one.  Obviously the guy doesn’t know any HTML, which is fine.

But that’s not all, dig a bit further and you’ll find:

class="MsoNormal"

Liberally sprinkled all over the place.  A bit of digging reveals the class MsoNormal to belong to Microsoft Office.  That’s right, there is a very good chance this whole thing was made with Microsoft Word.  Despite the fact that only an idiot would use Word to make a webpage.  Isn’t that just hilarious?

This of course is the crux of the issue.  He has proven that people use technology, especially computers, to achieve goals while having to learn as little as possible.  Any idiot can make a webpage in Word or any other WYSIWYG app.  Want bold – just click the bold button, insert an image?  No problem!  The fact that the code puts in <span style=”font-style: italic;”> instead of <em> matters not – after all the writer only wants to be a living demonstration of irony, rather than having to spend a significant amount of time learning HTML and doing it the proper way.

1: A logical fallacy will not suddenly become truth if you provide two pages of analogies.

Lying with analogies is fun.  It goes like this:

1. Make a statement comparing two things
2. Create a (tenuous) analogy to a real-world situation
3. Prove that your ‘side’ is superior in the analogy, so must be in real life.

Check this shit out, here’s his first ‘Why Linux rocks’ analogy

OS’s are like cars (it’s traditional)

1. Windows is like a normal car
2. Linux is like a motorbike
3. Windows has doors (as it’s a car)
4. Linux has no doors (as it’s not a car)
5. Windows is more likely to get broken into (viruses)
6. Linux is safe as it has no doors!

Makes perfect sense!  And there was me thinking that this was a complicated issue with nuance and subtlety. And it continues on, and on, and on.  Again the main substance of his argument: Any problem you have is with you not Linux.  If you have a problem it’s because it’s not Windows.

2: An outright wrong statement will not turn correct if you provide two pages of examples.

Let’s look at his views on Usability:

So it is that in most “user-friendly” text editors & word processors, you Cut and Paste by using Ctrl-X and Ctrl-V. Totally unintuitive, but everybody’s used to these combinations, so they count as a “friendly” combination.

So when somebody comes to vi and finds that it’s “d” to cut, and “p” to paste, it’s not considered friendly: It’s not what anybody is used to.

Is it superior? Well, actually, yes.

With the Ctrl-X approach, how do you cut a word from the document you’re currently in? (No using the mouse!)
From the start of the word, Ctrl-Shift-Right to select the word.
Then Ctrl-X to cut it.

The vi approach? dw deletes the word.

How about cutting five words with a Ctrl-X application?
From the start of the words, Ctrl-Shift-Right
Ctrl-Shift-Right
Ctrl-Shift-Right
Ctrl-Shift-Right
Ctrl-Shift-Right
Ctrl-X

And with vi?

d5w

The vi approach is far more versatile and actually more intuitive: “X” and “V” are not obvious or memorable “Cut” and “Paste” commands, whereas “dw” to delete a word, and “p” to put it back is perfectly straightforward. But “X” and “V” are what we all know, so whilst vi is clearly superior, it’s unfamiliar. Ergo, it is considered unfriendly. On no other basis, pure familiarity makes a Windows-like interface seem friendly. And as we learned in problem #1, Linux is necessarily different to Windows. Inescapably, Linux always appears less “user-friendly” than Windows.

To avoid #5a problems, all you can really do is try and remember that “user-friendly” doesn’t mean “What I’m used to”: Try doing things your usual way, and if it doesn’t work, try and work out what a total novice would do.

Well we know what a total novice would do, the writer of this article demonstrated it fine.  He’d use Ctrl-X and Ctrl-V to create a website using MS Word.

d5w, intuitive, really?  The only way you would ever know that is if you read the whole vi manual cover-to-cover multiple times.  It’s simply not guessable which is the very point of the word intuitive.  Edit->Cut is intuitive.  Ctrl-X is then intuitive as it told you the shortcut when you did it the long way.  It requires no prior knowledge.  That is intuitive.

The thing is most users don’t know about Ctrl-X and Ctrl-V, they don’t realise that Ctrl-Shift selects words.  Fundamentally 99% of computer users, when using Word, have read no manuals, have asked no questions and have no documentation.  I’ve seen people using Word who don’t even know about word wrap and press ‘Enter’ at the end of each line as you would in a manual typewriter.  Yet in the article writers mind somehow vi would be just as easy for them if they sat down in front of it rather than Word?!?  Of course, again, his argument is impenetrable – It’s not Windows.

But the insanity (and inanity) doesn’t stop there:

Subproblem #5b: Inefficient is friendly

This is a sad but inescapable fact. Paradoxically, the harder you make it to access an application’s functionality, the friendlier it can seem to be.

This is because friendliness is added to an interface by using simple, visible ‘clues’ – the more, the better. After all, if a complete novice to computers is put in front of a WYSIWYG word processor and asked to make a bit of text bold, which is more likely:

* He’ll guess that “Ctrl-B” is the usual standard

* He’ll look for clues, and try clicking on the “Edit” menu. Unsuccessful, he’ll try the next likely one along the row of menus: “Format”. The new menu has a “Font” option, which seems promising. And Hey! There’s our “Bold” option. Success!

Next time you do any processing, try doing every job via the menus: No shortcut keys, and no toolbar icons. Menus all the way. You’ll find you slow to a crawl, as every task suddenly demands a multitude of keystrokes/mouseclicks.
Making software “user-friendly” in this fashion is like putting training wheels on a bicycle: It lets you get up & running immediately, without any skill or experience needed. It’s perfect for a beginner. But nobody out there thinks that all bicycles should be sold with training wheels: If you were given such a bicycle today, I’ll wager the first thing you’d do is remove them for being unnecessary encumbrances: Once you know how to ride a bike, training wheels are unnecessary.

And in the same way, a great deal of Linux software is designed without “training wheels” – it’s designed for users who already have some basic skills in place. After all, nobody’s a permanent novice: Ignorance is short-lived, and knowledge is forever. So the software is designed with the majority in mind.

This might seem an excuse: After all, MS Word has all the friendly menus, and it has toolbar buttons, and it has shortcut keys. . . Best of all worlds, surely? Friendly and efficient.

However, this has to be put into perspective: Firstly, the practicalities: having menus and toolbars and shortcuts and all would mean a lot of coding, and it’s not like Linux developers all get paid for their time. Secondly, it still doesn’t really take into account serious power-users: Very few professional wordsmiths use MS Word. Ever meet a coder who used MS Word? Compare that to how many use emacs & vi.

“Ever meet a coder who used MS Word?” – no, but I’ve read a few articles by one.

The mind boggles at the stupidity of this.  He is basically arguing for software to take away the shortcuts and basically massively increasing the barrier of entry.  I though one of the main aims of modern computing is to bring the benefits to the masses, after all you don’t need to be a mechanic to drive a car, a plumber to flush the toilet or an electrician to use a lightbulb.  Sure, he may think that forcing people to study for hours before being able to do the slightest thing is advantageous, but the fact that just about everyone (including him) would rather use software, rather than learn software, says it all.  If he actually believed what he said he would have learned HTML, rather than just used the ‘training wheels’.

PSA: If you use some arcane shortcut key or in-obvious key sequence it does not give you a better quality of bold than if you click on the bold button.  It’s just as bold, except it didn’t take 3 days to work out how to do it.

PSA2: The really, really stupid thing is learning how to use vi does not give you a better understanding of how a computer works – it just means you have wasted loads of time.  Does knowing d5w give you a fundamental insight into the machine?  Or is it just a relic of a time when text-only is all you had?

What is amazing though is that he appears to speak for Linux – (maybe he’s channelling the spirit of tux?) – and likes to say what Linux is, what it isn’t, and even says in his summary:

It’s great, but it’s not the point. The point is to make Linux the best OS that the community is capable of making. Not for other people: For itself. The oh-so-common threats of “Linux will never take over the desktop unless it does such-and-such” are simply irrelevant: The Linux community isn’t trying to take over the desktop. They really don’t care if it gets good enough to make it onto your desktop, so long as it stays good enough to remain on theirs. The highly-vocal MS-haters, pro-Linux zealots, and money-making FOSS purveyors might be loud, but they’re still minorities.

So he is speaking for the thousands of developers (I hope he consulted them first) and got the consensus that none of them want Linux to be a success, and don’t really care about the normal users, just about catering for the already computer literate elite.

I think he’s missed the point: Linux is free, in all senses, as people like him love to state at length.  So why does he have the right to say what it is, and isn’t, what it should be and shouldn’t be, who it’s for and who it’s not for?  What is to stop anyone (who has the time and money) to create a fork to do everything that he says it isn’t?

Linux isn’t anything, it’s just a collection of software packages that happen to be released under a permissive license – that is all.  They are created by exactly the same people that make commercial software, in exactly the same way.  Talk about ‘community built’ all you want but there is no effective difference between a volunteer squad of 10 and a company hiring 10 people.  It’s just software – would Windows change fundamentally if MS just GPL’d the whole lot one day?

Linux, if this guy is their representative, is a collection of elitists who want people to think they are smarter than they really are by using complicated software (And acting like it’s easy) to try to impress.  That is if you really have to put a label on it.

So what was this event you may ask?  In a nutshell, large portions of the Linux, and FOSS, community realised they had a usability problem and looked like they were starting to take it seriously.  It was largely triggered by this post, The Luxury of Ignorance by Eric S Raymond (and part 2) and although he didn’t say anything that hundreds of people were not already saying, for such a heavyweight of the FOSS community to say such things was unheard of.  Everyone was pretty much forced to sit up and take notice.  For a while you could even suggest in public that Linux was seriously lacking in usability and only be flamed to a partial crisp.

Many Open Source Usability cottage projects sprang up, and several large projects announced that they were putting usability to the forefront – I distinctly remember a quote from Gnome stating they were putting usability at the centre of their effort.  It was meant to be a new dawn of user friendly FOSS.

That was five years ago.  So what went wrong?

The nail was, amusingly, hit pretty much on the head almost immediately by John Gruber with his article Ronco Spray-on Usability in which he makes my first point, and to quote:

UI development is the hard part. And it’s not the last step, it’s the first step. In my estimation, the difference between:

• software that performs function X; and
• software that performs function X, with an intuitive well-designed user interface

isn’t just a little bit of extra work. It’s not even twice the work. It’s an entire order of magnitude more work. Developing software with a good UI requires both aptitude and a lot of hard work.

Which is exactly true.  You cannot code leaky crap in C and expect to easily fix it later, you cannot easily retrofit security as an afterthought (ask Microsoft about that one), so why the belief that usability is just a theme-pack away?

Anyway, there’s been a five year wait, which is a literal ice-age in terms of computing – why the lack of progress?  There is a simple answer:

Programmers for FOSS projects are largely not interested in usability.

The simply proof for this is that if they were, it wouldn’t be a problem.  The majority of good programmers I know are not programmers because they picked it in university because they thought it would make them money, but were in fact born programmers.  It’s almost a calling – and I know this because I started when I was 8.

However the sheer fact that a ‘call to arms’ is even necessary demonstrates how little interest their really is.  Which brings me to my second point on why so little has been achieved:

All the effort on fixing usability has been aimed at making the FOSS developers better at usability rather than trying to involve the people who actually know about it.

The unfortunate ethos of the FOSS movement appears to be ‘The Programmer is King’.  Unless you are personally willing to fork the project and code it youself, the chances of having any input on anything, irrespective of ability, is pretty much zero.  Even the attempts at engaging non-developers suffer the same fate

Adventures in Failure

Every now and then I forget this key point (do it yourself or GTFO) and stupidly try to ‘contribute’, the last time being a couple of years ago on the run up to the Hardy launch (moving forward in time a few years).  Again it was another time of optimism and there was a call for non-developers (the ridiculous thing about all this is I am a developer.  Full time.  Paid) to help contribute to the Ubuntu art team.  Now I am not amazing at graphic design, but passable, and have spent quite a few years doing it as I realised I had an interest.

Since I whinge a lot about what should be done I thought I’d put my money where my mouth is and give it a bash and maybe help do some good.

So I signed up to the mailing list, created a very basic (but indicative of the direction I wanted to go in) design and started posting (first design ever is here).  A few people liked it, a few people hated it, I received a bit of feedback, acted on it, and posted again.  As this cycle continued though and as I saw many people much more talented than me post work, get comments, then disappear I realised something surprising: Nobody with any actual authority over anything was bothering to read the mailinglist or look at the wiki.

You’ll remember the launch of Hardy and the exciting new theme culminating in a fancy wallpaper – It had nothing to do with the quality of the submissions.  Rather than as in every single professional design project I have worked on where several concepts are submitted, whittled down to a few and then to one, it was clear that this process was never going to happen since there was nobody at the wheel who was going to make the initial choices.

I never received any feedback from anybody official on my work, and the bulk of feedback was solicited by spamming various Linux forums with links asking for opinions.  Again if this was a professional business I was dealing with who were paying me to do it I would be told Yes/No and given reasons for the decision from which point I would either go back to the drawing board or work on addressing the issues raised and thus be able to move forwards.  Alas, nobody was at the wheel and all you could hear was the sound of crickets.  As a result it’s impossible to improve as there is no indication of *what* needs improved.

I started pushing the issue after a while as the deadline for Hardy was a few months away and even if my design was not considered (I didn’t really expect it to be), at least someone else’s would have been that I could have helped out on – I was willing at this point to learn how to do some theming too.  But again, there was no official decision or feedback.

Soon into this discussion it was made clear that if I wanted my design to be considered I should ‘Make a theme out of it and post it on Gnome look’.  So what started as a campaign to involve non-developers in Ubuntu – and bear in mind this is just a skin-job and not even touching the usability elephant in the room – turned into a ‘learn to program, we’re not going to do it for you’.  I was pretty much expected to sink dozens of hours of my time into creating a theme, adding it to an already massive list and then hoping the Ubuntu devs spot it on the off chance that they actually look through that site.

Ultimately Linux development is only for those that 1: have the time and 2: are programmers, and despite the lip service they pay to usability and design, the focus on a developer-centric solution to every problem is simply not yielding any results.

Luckily the fix is ridiculously simple.  This usually occurs in IE, but this may fix it for other browsers also. Simply put:

<script type=”text/javascript”>
Cufon.now(); <!– avoid the fouc in ie with cufon –>
</script>

Somewhere just before the closing </body> tag and the problem is solved.  If only everything in life was that simple

$sql = “SELECT `name` FROM `tablename` WHERE `id`=’45′”;
$res = mysql_query ($sql);
$row = mysql_fetch_assoc ($res);
$name = $row['name'];

But if you use list () and mysql_fetch_array () you can trim it down somewhat…

$sql = “SELECT `name` FROM `tablename` WHERE `id`=’45′”;
$res = mysql_query ($sql);
list ($name) = mysql_fetch_array ($res);

Since mysql_fetch_array returns a numerically indexed list, and list () pulls the values of the resulting array to the specified variables, you don’t need to get the return and then extract the value from the array since you can do it all in one line.

In fact I generally abstract this whole block out to a function such as:

function sql_get_element ($table, $column, $value, $search=’id’)
{
$value = mysql_real_escape_string ($value);
$sql = “SELECT `$column` FROM `$table` WHERE `$search`=’$value’ LIMIT 1″;
$res = mysql_query ($sql);
list ($name) = mysql_fetch_array ($res);
return $name;
}

So if you wanted to fetch the name from a table with a specific ID you could do this:

$name = sql_get_element (‘tablename’, ‘name’, 45);

Thus cutting out a lot of the nonsense SQL calls, plus you centralise the data escaping to help ward off those troublesome SQL injection exploits.

Don’t get me wrong, load times are not that horrible at all – in fact if you have only a couple of transformed elements on the page it’s nearly instant, but it does slow down in proportion to the amount of transformed items so if you do everything it’ll basically grind to a halt for a few seconds every time the page refreshes.  This is obviously not really acceptable.

The problem I was having was that there are about 10 main menu items with about 10 sub menus each.  This means it takes about 2 seconds to load in IE (it’s the slowest, unsurprisingly).  The plan was to transform only the top level items and then only do the dropdowns (it’s an accordion but that shouldn’t make a difference) when the user hovers on the top level item, rather than doing everything on page load.

Here’s the code, assuming that the main <ul> is in a <div> called #products-menu, and it follows the standard ul li a format, with the sub ul’s nested in the li’s.

    <script type="text/javascript">
        $(document).ready(function(){
            // Dynamically load cufon on drop downs
            $('#products-menu>ul>li').hover(function() {
                $(this).addClass('cufon');
                Cufon.replace('.cufon ul li a');
                $(this).removeClass('cufon');
            });
        });
        // Load Cufon on top level items only
        Cufon.replace('#products-menu>ul>li>a');
    </script>

It also uses jQuery, so you’ll need to include that in the header also.  Anyway I hope this helps someone!