Linux Fest Northwest 2010 wrapped up less than 24 hours ago, and it was (as usual) a great show.  The full Jupiter Broadcasting crew was there and had an absolute blast.

On the first day of the show I gave an updated version of last year’s “Why Linux Sucks.  (And What We Can Do To Fix It)” session that I know many of you wanted to see (the room got pretty crowded, and I know many couldn’t make it inside).  So here it is, in all its glory…

Why Linux (Still) Sucks.  (And What We Can Do To Fix It).

And here are the slides from the presentation (in Open Office format, of course!).

For those interested, we also talked about Linux Fest NW in the latest episode of the Linux Action Show.

Ogg and h.264 versions of the video can be downloaded from the Jupiter Broadcasting page as well.

Over the last decade or so I’ve had the opportunity to work on a number of different platforms, using a lot of different languages and architectures.

This has been both a blessing and a curse.

On one hand, it has given me the chance to find out what really works best for any given project.  PHP, Ruby or Java?  C, C++, C# or Python?  And that doesn’t even get into the operating system, and framework options (and which MVC-ish model, if any, to use).

On the other hand… it has been a royal pain in the posterior.

I now have code (good, functional, worth-while code that does cool things)… but the likely-hood of being able to re-use that code on new projects in the future?  Pretty damned small.  Sure, it’s possible on occasion (and those are glorious occasions), but just not often enough.

I am not a fan of re-inventing the wheel.

So what is one to do?

Currently… there is no great solution.  Other than, perhaps, stick to one programming language and set of frameworks for as long as possible to maximize your investment.

But that simply is not an option for most developers.

So I’ve decided to try something… a little different.

Follow along with me until the end.  Some of this has been done before.  But not quite like this.

To start with, here’s what I want:

1. The ability to deploy a project, with as few changes as possible, to any target.
2. That deployment target should be in the form of source code.  Python/GTK, C++/QT, PHP & Javascript, etc. tailored and ready for specific platforms (Linux, Windows, Android, etc.).
3. Extreme modularity.  If I create a bit of functionality, I want to be able to easily “wire that up” in a new way within the same project, or implement it within a new project with as few modifications as possible.
4. The UI modifications for an application for targeting different platforms (Desktop, Web, Mobile) should be handled within the same project without logic changes.  ie: No branching projects to support a new platform.
5. When I write the logic, I want to do so visually.

In a nutshell: I want the software development of the future.  Somewhat like what we often see in the movies.  But I want it to be real.  And I want it to be practical.

Sometimes pictures simply work better… So here’s a (very) simple example of what I’m talking about:

In the above example the “Hello World Window” is an object representation of an actual window.  That window has been design using a visual designer and an “OK” button on that window has been connected to a Clicked event.

Then, that clicked event is connected to a Message Box object that has been added to the project (we’ll get in to how that object knows what message to actually display later, for now let’s keep it super simple).

What then?  In theory we’d have the equivalent of a pretty standard Hello World type application, right?  Click a button and a message is displayed.

Now we’d need to have this development tool be able to generate the code to actually make that happen.  Maybe we want a Linux application that is in Python using GTK.  Maybe we’re looking for C#/WinForms application.  How about an Obj-C/iPhone app?  Or, just maybe, we want a nice Javascript based website.

What would prevent us from having a tool that generated the necessary code based on this connected object model we just saw (which we could then either run directly, or build using other compilers into standalone applications)?

Nothing.  Absolutely nothing would prevent us from doing this.

There are certainly technical hurdles, but it is very, very doable.

Even complex logic is doable here (albeit not in the “traditional” way).

One thing worth noting:  That small screenshot is not a mock-up.

This is the Illumination Software Creator.  And it is currently under development.

If you would like to participate in testing out the alpha version (and it is, most definitely, alpha quality) that information will be posted to the Illumination Software Creator Facebook page.  That is where the discussion and support will be happening.

The first Alpha release of Illumination is focused on creating Python/GTK applications and will be available soon for Linux, Windows and MacOS X.

I kid you not.  The state of Washington, my home, is looking to begin applying sales tax to developers of custom software solutions.

This could be a huge rock-over-the-head for people in my line of work (custom software development).

This is all thanks to House Bill 3191.

The net result is that either a) I’ll have a significant decrease in income per job done for a client or b) my rates will increase, thus reducing my ability to stay competitive.

And, if you think this doesn’t apply to you, let me ask you this:

• Do you design custom web-sites?
• Do you update blogs that contain custom HTML snippets?

Then this very well might apply to you too as, technically, that is software.

Either way… I, and companies and individuals like me who develop custom software (in any way) for others, will loose money.

Also… how does this apply to open source software?  If a developer gets paid to write an open source bit of code either in WA state or for a client in WA state… does that apply?  It seems, from the bill, like it does.  But it’s not specifically called out that I can see.

The Washington Technology Industry Association is fighting it.

More information can be found here and here.

If you live in Washington, and disagree with this bill, please contact our governor and your legislator(you can find that information here).

Tell them how much this hurts independent software development in the state.  Tell them how this will drive tech companies to other states.  Tell them how much it hurts the little guy.

One of the great things about Linux (on the desktop) is the wide variety of options available.  Linux, as many would say, “is all about choice”.

KDE or GNOME?  RPM or Dpkg (Deb)?  Red Hat or Debian?  The various options available to Linux Desktop distros (distributions) are almost… limitless.

But which options, exactly, are people using?  And how has that changed over the last several years?  And what does that tell us about where Desktop Linux is going?

This is all incredibly difficult to answer due, in large part, to the difficulty of gathering reliable numbers on the usage of the various desktop Linux versions out there.  And, even when good numbers are available for one Linux distribution, often those numbers are collected using a different method than another distribution.

The best source that I know of for “ranking” all of the various distros (based on how many hits each gets per day) is DistroWatch.  This isn’t going to be 100% accurate, but it’ll give us a good indication on trending (and, from my experience, it seems to be fairly accurate).

So I took a look at the numbers DistroWatch provides for all of the “top distros” (this was me simply choosing the most popular distros over the course of several years) and put them in a chart covering 2003 to the present day.

Popularity Per Distro (Click for larger view)

Okay.  That’s… interesting.  And it gives us an intriguing peek at growth over the years.  But these numbers are skewed by DistroWatch.com’s own growth as well as the general growth of Linux.  What I really want is a percentage of the total Linux Desktop market-share…

So I took those numbers.  Totalled them up.  And created a chart of the percentage each Linux distro had, on average, during the course of each year.  Obviously many great Linux distros are left out of this, and that has an impact on the numbers, but these represent the majority of the market-share at any point.

Distro Popularity Percentage (Click for larger view)

Now there we go!  This paints a much more realistic picture of the market-share each Linux distro had during any given year (obviously still not 100% accurate… but about as close as we’re going to get).

Okay, a few things really jump out here.

2003/2004 was a very different time than what we have now:

1. Mandriva (then called Mandrake) was king back in 2003, 2004!
2. Fedora and KNOPPIX were in amazing shape with percentages in the teens.
3. Debian, Gentoo and Suse are all doing quite well.

Then, in 2005, Ubuntu happened.  Sure, it was released first in 2004… but in 2005, Ubuntu broke the 20% mark to become the “king of Linux distros”.

During that same year Red Hat and Mandriva took a hit that they never fully recovered from.  Just look at that light blue line as it dips southward.  Poor, poor Mandriva.

Flash forward to today… and things seem to have stabilized a bit.  The only dramatic motion seems to be the decline of PCLinuxOS (from its perch as a “rival to Ubuntu” in 2007, down to the middle of the pack by the very next year) and, almost at the same time, the rise of Linux Mint, who came out of, seemingly, nowhere to challenge Fedora and openSuse for the number two spot.

But what does this mean?  Does this give us any indication of where things are heading?  To figure that out I decided to consolidate this chart to represent the “core” distros.  Most distributions are built on top of other existing Linux distributions (Linux Mint, for example was based on Ubuntu).  So I rolled all of these distros (where relevant) up into 4 “parent” distros.

Parent Distro % (Click for larger view)

In 2003 “Red Hat was Linux”.  Or at least this is how many people thought.  And, with a 40% market-share, of Red Hat and Red Hat-based Linux distros… that seems about right!

Then there’s that pesky 2005 again.  Ubuntu-based distros (including Kubuntu, etc.) hit 25%.  Catapulting Debian (which Ubuntu is, itself, based upon) up to over 45% and knocking Red Hat down to 30%.  (With me so far?)

And Suse / openSuse… has stayed pretty much steady around 10% all these years (old reliable!).

Red Hat-based distros made a small come-back during 2008, but seem to be on the decline again.

Worth noting: Ubuntu-based is sitting at over 40%, with Debian-based sitting only a slight few percentage points higher (this is even with Debian proper taken into consideration).

What does this all mean?

1. The vast majority of all Debian-based distributions of Linux (in terms of market-share)… are also Ubuntu-based.
2. Fedora (and derived distros) are, by no means, out of the game.  Owning over 25% of the market is a pretty big deal no matter how you look at it.
3. But.  Fedora is on a downward slide right now in usage it seems.  While Ubuntu is on a slow up-tick (or staying roughly the same depending on how you look at it).

While I was at it, I wanted to also see which Desktop Environment each of these distros used.  And how each stacked up over the years in terms of market-share.

Desktop Environment % (Click for larger view)

Holy guacamole!

I knew KDE was a bit down (in usage) from its heyday.  But that’s a pretty extreme drop!

KDE and Gnome seem to have, over the course of about 3 years, switched spots.  With most of the movement in… you guessed it… 2005.  It’s that silly little Ubuntu again.  When Ubuntu hit, and went big, it pulled Gnome up with it.

And KDE still seems to be on a slight downward slope (despite or, perhaps because of, the release of KDE 4).

So where does that leave us?  Where is desktop Linux heading?

There are still some unknowns.  But a few things are becoming clear:

The “Linux World” (and, by that, I mean people who actually use Linux as a desktop system) is gravitating towards Ubuntu and GNOME.  In large numbers.

Does that mean KDE, Fedora, Suse, etc. are dead?  No sir!  All of the distros listed above still command a very healthy market-share and dedicated user base.

But these other distros are quickly becoming “Ubuntu Alternatives“.

That’s a pretty major change from where things stood in 2003.

And I think it is awesome.

Why?  I’ll give you two big reasons:

1. It allows a clear, consistent image of “Linux” to be portrayed to the general public.
2. It allows developers (of both open source and closed source commercial software) to focus on one single environment first.  This can save a great deal of time and money, and allow for higher quality software.

Some people may not like this (okay… I know many people who don’t like this), but it simply looks to be the way things are going.  I’d be willing to bet that, in a few years, people will equate “Ubuntu” with “Linux”.

But really, it’s not like the other choices have gone away.  And it’s not like the Linux Action Show is going to suddenly become the “Ubuntu Action Show” or something nutty like that.  But the numbers don’t lie.

It finally happened.  After several years… Jupiter Broadcasting finally has a store… store.JupiterBroadcasting.com.

We’re still fleshing it out and adding more goodies, more clothing and the like.  But it is live and fully functional right now.

We don’t handle any of the transactions ourselves.  All purchases end up going through Amazon, Printfection (for the clothing), etc..

Along with the store launching you can find the Jupiter Broadcasting clothing line-up.   Including Linux Action Show shirts and hoodies… as well as shirts that, ahem, make a statement.

We also have sections dedicated to Star Trek, Comics, Linux… and other geeky pursuits.

Every purchase made through the store goes towards off-setting the cost of producing the shows at Jupiter Broadcasting.  We don’t get much per sale, but every little bit helps!  (And, besides, it doesn’t cost you any extra to go through our store than through Amazon.com directly… so why not, right?)