TuxTips

I was reading a discussion on Reddit today about the release of CentOS 6, and as inevitably happens when geeks get together to talk about Linux distributions, the topic of stability came up, and not for the first time it occurred to me just how problematic the phrase can be.

The problem is that there are several valid and reasonable definitions of stability, and it is quite often difficult to divine from the context of a conversation which definition a particular person has in mind when they are discussing the stability of a given distribution, platform, or application. Further more, I have the impression that many people have never considered that there might be different meanings than the one that they themselves have adopted.

In light of this, I wanted to talk today about a couple of the meanings of stability, how the concepts differ, and why understanding the nuance of the different meanings is important when making decisions about what platforms to embrace and which to eschew.

The first definition of stability is the one that I think the average person will most associate with the word, and that is “software that doesn’t crash”. We might say something like “Foo is a very stable application”, and mean that when using Foo unexpected failures are a rare event. Having a word with this meaning is important because all software undergoes cycles of active development where Bad Things are more likely to happen, and periods of bugfixes and maintenance where the software becomes more reliable. For a user deciding on a piece of software to use, understanding where the software is in the life cycle, and making decision about where to live in the cutting-edge/well-tested continuum is important.

The second major definition of stability is one that we see used in discussions about many Linux distributions, and is the one that unfortunately is most often confused with our previous definition. In this case, stability means “The packages and configuration of the system change infrequently”, and goes hand-in-hand with longer support cycles and a better guarantee of bug fixes and security patches. When people talk about debian stable, or the stability of a distribution like RHEL, it’s important to understand that this is the definition that they are using. This type of stability is important to businesses, where a distribution with infrequent package updates and a longer timeline for issuing security fixes is important both in maintaining an operational environment as well as ensuring the developers are able to write applications without chasing a moving target.

Differentiating between these two differences is critical when determining what software is appropriate for your use-case. While it is often the case the the versions of software selected for long-term support are chosen to coincide with the bugfix/maintence points in the software development cycle there is no indication that to converse is also true. Many distributions offer a rolling release with frequent package changes and updates while still maintaining a high level of quality control on the packages that are pushed out.

The site is currently being revived and revised. Comments and registrations are currently disabled.

I just got my invite a couple of days ago to the beta of Stack Overflow. I’ll save an in-depth review for once the site has officially launched, but I just thought I would write a quick post to say that so far I’m pretty impressed. The site is fast and well designed, and I’ve not run into any major bugs yet. The community seems to be solid (although not as many linux systems developers as I’d like to see) and the reputation system seems like it’s well designed. This looks like it could turn out to be another good site for programmers. I’ll be sure to make a post here once the site goes live, and in the mean time if any of you are already in the beta, my username is CodeninjaTim, so be sure to keep an eye out for me.

In the last article in the Journey to Python series, I had gotten as far as doing some basic math, and displaying some data to the screen. Over the last few days I’ve been working on two new facets of Python which will hopefully allow me to get up to speed in writing programs that are actually useful. This week I’ve played around a bit with reading input from the command line in a python program, as well as interacting with the operating system with the OS library; I’ve also had a chance to look at pydoc to get some documentation, and as per a reader request I’ve spent a bit of time thinking about pythons type system, and how it compares to more strict type systems in languages such as C++ and Java.
Read the rest of this entry »

After yesterdays rather long introduction into the whys and wherefores of my decision to learn python, today I’m going to begin to talk about my first steps into learning python. In this post I’ll talk about how I fared getting up and running with python, what references I chose, and discuss my impressions after writing my first program.
Read the rest of this entry »

There is something that I have to admit, even though it may cost me a few geek points. I’m not fashionable. I’m not quite the old codger who things things were fine with punchcards and this internet thing is just a fad, I certainly enjoy using the latest version of $whizbang_app, and I’m happy to upgrade my hardware with acme’s Greatest-Thing-Ever(tm). I was using Linux on the desktop when most people were trying to decide if they should upgrade to Windows 98, and I was running Compiz when it was just a couple of tarballs and a neat video from Novell. In certain areas however, I am far more conservative.
Read the rest of this entry »

/proc is often considered one of the most mysterious parts of the linux file system.  For those comming from the windows world especially, but also those who have been using Linux for years, proc seems an at times incomprehensible web of mysterious files and directories.

Understanding the mysteries of /proc can greatly aid in administrering and programming on linux systems, because proc is itself a key into the depths of the system.  In some ways, proc can be thought of as similar to the windows registry; it contains specific files that contain information about the system, and control how the system operates.

Read the rest of this entry »

A few days ago I decided to start learning Japanese. I expected to have a difficult path ahead of me, as Japanese is a notoriously difficult language for westerners to learn. After running up to my local bookstore, and picking up several books and CDs on the Japanese language, and getting the Adobe Shockwave plugin installed using Crossover Office (A great version of wine, I definitely recommend it if you find the vanilla wine to be too cumbersome); and making myself slightly poorer buy getting a subscription to the online version of Rosetta Stone I found myself facing a difficulty that I hadn’t originally expected. My English version of Slackware with Dropline Gnome and a US keyboard layout allowed me no easy way to insert Japanese script into documents. This meant that I would have difficult learning to read and write Japanese, as well as practicing Japanese by talking with my Japanese speaking friends online.
Knowing that there had to be a solution to this problem, I set out on the internet to find out. Unfortunately, the general (and reasonable) assumption is that if you want to be able to input Japanese characters, you probably read Japanese. For someone just learning the language, I found a lot of the documentation rather incomprehensable. With some effort I figured out how to get everything working, and have here a guide that should help others who want to enable Japanese character input.
Read the rest of this entry »

One of the great benefits of Linux is it’s extensibility. For Gnome users, one of the great ways that you can easy expand and customize your desktop is with Nautilus scripts. In this article I discuss using Nautilus scripts to enhance your Gnome experience, as well as providing a couple of starter scripts.
Read the rest of this entry »

I thought that today, rather than going for an in-depth tutorial, I would post a useful snippet of code for anyone out there doing GUI development with GTK+. Although Gtk+ is a nice toolkit, one thing that I found that it was lacking was a nice widget to automatically display directories. I had hoped that since it had such a nice file open dialog, there might be something out there, but alas I was unable to find anything. So, I present here a useful function to automatically populate a GtkTreeView with a directory structure.
Read the rest of this entry »