Couple of years passed and I am now looking into Bazaar. This is a relatively new distributed version control system. I think I’ll write more about Bazaar, but in the meantime, I’d like to share some thoughts that crossed my mind while I was playing with it.

There’s one thing that distributed version control does much better then centralized version control. Let me explain.

We do commits for two reasons.

1. We want our work backed-up. We commit to repository because we know that repositories being backed up.
2. We want to be able to track our work, i.e. keep a record of changes that we apply to the project.

In centralized version control system, these two are integrated in one system. I.e. if you want to track your changes, you commit. If you want to backup your code, again, you commit.

Don’t know how about you, but for me, this is totally broken. I work on a small projects, usually from home. I prefer not to host Subversion server on one of my home computers, but rather have a small VPS system for this purpose. It has mirrored disks, so the data is safe, more or less.

The problem is that this setup is horribly slow. It uses web front-end, so it creates a new secure connection to the server for every file I commit. This is so frustrating. I bet Subversion has faster front-ends, but I doubt they will be fast enough.

On the other hand, with distributed version control, the two above items are separated. When you commit for code tracking purposes, you commit to your local repository. When you want to backup your code, you commit to centralized, backed-up repository. In the first case, you can commit as often as you want – do local commits, in Bazaar terms. In the later case, you can commit to the repository, lets say, nightly.

So, despite distributed version control systems naturally fit large projects, my mini-projects can enjoy them as well. Hence I am definitely going to try Bazaar with one of my mini-projects and report the results. Stay tuned.

Related posts:

1. Bazaar for subversion users, part 1 – the basics
2. 2 reasons why small package repository is better than large

In case you don’t know, this is the program behind large portion of the Linux command line. It is the program that actually makes majority of work turning Linux command line into such a magnificent tool it is.

As for use frequency, on my computer the only program that beats it is perhaps a web browser. I use it more often than mail client, text processor or just any other program.

Now, one thing that entertains me is that there is absolutely no hype around bash. I mean, you probably know that next version of Firefox coming tomorrow (I am writing this on June 9th, 2009). But do you know when next version of bash is coming? Do you even know what is the version of bash that you currently use? Well, you are not alone – I have no clue either

One thing that concerns me is that bash almost didn’t change for the last ten years. I mean the only new feature that, to my knowledge, it didn’t support ten years ago is bash_completion – that is the advanced version of plain completion that it does to files. I could be wrong about this of course, but one thing is certain. Whatever the changes are, they are unnoticeable.

So, I thought that I’d compile a list of features that I would like to see in the upcoming version of bash. Now really, if only one of them would become a reality, I’d chew my pair of orange Crocs (I do have a pair of orange Crocs), put it on video and post it on youtube. Alright, I won’t do that. But it would still be very nice to see these happening.

The list:

1 – History sharing

I often open multiple shells. It would be really nice to be able to synchronize history between them. Right now, it seems that bash writes history file when it shuts down. If you open another session after history has been saved, you can access commands that you’ve typed in in the previous session. Otherwise, the history between two sessions is completely independent. Not good.

2 – Completion of directory and file names based on their usage

I think that 90% of cd‘s that I do are all destined to the same directory. Why on earth I see the list of possible destination for cd in alphabetical order every time I press TAB?

3 – Completion of make targets

I know this has already been implemented. But I am wondering why it isn’t part of bash_completion package on Ubuntu. OpenSuSE is no better – it does completion only to some yast stuff.

4 – Show a browseable and searchable list of files when hitting TAB key twice

I guess you all know that. Single TAB key completes a word if it can make a single match. Double TAB shows a list of choices for completion. In case the list is too long, it builds a long list and pipes it through more.

What I would like to see is a browseable and searchable list. One that I can browse with arrow keys. I also would like to be able to enter portion of the file name and in that case bash should filter out everything that doesn’t match the criteria I’ve entered.

5 – Completion of scp, on remote host

I guess it happened to all of us. Copying file to a remote computer with scp, is always difficult because you actually have to remember the path on remote computer. Wouldn’t it be great if bash could complete remote paths as well?

Now, I know this is very difficult to implement. Basically you have to spawn ssh with ls command, wait for it to complete and parse the results. Oh and there is a password thing. You gotta take care of password prompt that ssh may produce. Have no idea how to solve this issue. I do see a couple of options, but all of them are far from being ideal.

6 – Fix typos

This one is simple. As long as I don’t hit the TAB key, no need to fix anything. Once I hit the TAB key, shell should check if the command I’ve entered makes sense and if not try to fix it. Good example of what could make sense are file names. vi <filename> probably means that you want to edit a file. If the file does not exist and yet there’s another file with almost identical name, fix it. Same with cd. You don’t cd into directories that don’t exist. So once shell detects an attempt to do so and the user asks for help (by pressing the TAB key), shell can fix the typo and make the user smile.

This is it. I hope to see any of these happening one day. In the meantime, enjoy the list and by all means leave comments with your ideas of bash enhancements.

Related posts:

1. One sane voice in the crowd
2. Creating new application on top of SSH
3. Is desktop Linux too fragmented to succeed?

The article argues that the fragmentation is what keeping Linux Desktop from beating Mac OS and even Windows. It is because the effort to create Linux desktop is scattered across multiple distribution, it cannot become a serious player in desktop solutions.

Toward its end, the article gives optimistic prospects. There are some efforts to bring Linux desktop community to common ground, unanswered though.

This is so wrong

The truth is that are some points in the article that made my eyebrows go up. You see, having single desktop Linux distribution is impossible. This is against the nature of Linux and how its being distributed.

To get it moving you have to talk big distributors into this. But for big distributors, their desktop solution is one way or another their selling point. RedHat compete with Novell through Fedora and OpenSuSE. Moreover, they don’t want common ground. They want to compete.

Small distributions want their piece of the big cake too. Asking them to provide the same desktop solution would be as asking them to close their business – if they wanted to be a part of joined effort to make the world better place and Linux better desktop OS, people behind the distro could simply join someone else’s project.

Actually, this entire idea seems to be taken from socialism. We take something from everyone and create something that everyone would use. Sounds great, but this creates so called moral hazards. This strips away the will of competition. And competition is the driving force behind many of the technological marvels that we see today in general and in Linux in particular.

The only way to improve Linux’s position in desktop market is

to invest money into development of better Linux desktop.

Actually the author of the article was addressing the same issue, but from different angle. Linux desktop needs money. It needs more graphical designers, more QA engineers and more software engineers.

It straggles to become a serious desktop operating system because no one did usability testing. Because no one hired best UI designers, as Apple did. Because no one had hired enough QA engineers to make sure that all the software indeed works.

One way to overcome this problem is indeed by combining the effort. The problem is that Fedora isn’t there to beat Windows in desktop OS market. Fedora is a beta version of RedHat’s server systems. Same can be said about OpenSuSE, Ubuntu and most of the Linux distros.

Obviously money can be spent on nothing useful. Hundred engineers will not do in one month what ten engineers do in ten month. However, financing creates opportunity. And opportunity is exactly what Linux desktop needs.

Related posts:

1. Ubuntu 9.04 with Wubi – Failure
2. What kept me from sticking to Ubuntu as a desktop solution
3. 6 things that I miss in bash

Wubi is a program that installs Ubuntu Linux on top of installed Windows. I already had a Windows installation on my laptop, that I didn’t want to destroy. This is why I’ve chosen Wubi. It places root file-system in a file on Windows partition. Because of this feature, you don’t even need a partition to install Ubuntu.

What got me into this

What got me into Linux desktop frenzy this time, is Vista’s slowness. We all know various virtues of Microsoft’s operating systems. But installing Linux desktop instead… Silly me. It took me just four hours to figure out that I am better with slowness. Four hours I usually don’t have.

I am full of respect to developers of Linux. I work with Linux and develop for it for many years and I think this is a great server platform, unmatched by any other OS. But, Linux desktop is unfortunately isn’t too mature to be a serious match for Windows as a Desktop OS.

Knowing this from my previous attempts to install Linux desktop, I tried a less destructive option out of all. That is, Wubi doesn’t change your existing Windows installation. It install Ubuntu Linux as if it was another Windows program.

Installing Wubi

Problems started with Wubi itself. I live in Israel and although I use English version of Vista, Wubi installation has decided that I am better with Hebrew. Entire installation procedure was in Hebrew.

Next, despite I explicitly told Wubi that I want English version of Ubuntu, it installed Hebrew version. I checked on Wubi’s web-site and it appeared someone reported this particular bug just few days before. And it already had a solution – developers presented a new revision of Wubi which wasn’t yet publicly available, but solved the problem. The installation interface language remained Hebrew, but at least it installed English version of Ubuntu.

Now in case you wonder why I had to reinstall entire operating system just because of interface language, I’ll explain you. You see, I am not very familiar with Ubuntu’s graphical interface and I didn’t know how to configure wireless network. Hebrew interface made it even more complicated for me, so I decided to get things right form the start and not to begin tackling problems on unfamiliar ground.

On the other hand, because I didn’t have internet access, I could not just install English support it as I would do otherwise.

Now to Ubuntu

My next task, after installing the Linux itself, was to configure wireless network. The installation program did detect both wired and wireless card. However, the network interfaces configuration program didn’t show the wireless interface – only the wired. Luckily, simply pressing Add solved the problem. New dialog, popped up, asking me what is my SSID.

I am lucky to have some background in wireless networking, otherwise I would not know what SSID is. In case you’re wondering, this is the name of your wireless network. Anyway, it appeared that I’ve forgotten name of my wireless network and I had to use my cell. phone (which luckily supports wi-fi) to find the name. Not to mention I’ve absolutely forgotten that I’ve used WPA2-PSK security for my network. I had to choose it manually too, but before that I had to investigate it with my cell. phone.

I must say that Ubuntu could ship a program that scans for wireless networks, but it just wasn’t there.

On the bright side, once I entered right values for SSID and encryption, it got connected immediately.

The breaking point

The next thing I planned to do was mounting my Windows partitions. Somehow mounting my C: drive wasn’t that difficult. The desktop was empty. I right clicked on it, created a new directory and then double clicked on it. It opened gnome file explorer. Then I pressed the computer button and here they were, my CD-ROM and C: drive. Clicking on C: drive, created a C: drive icon on the desktop and I could safely delete the directory I created, knowing that I can always open gnome explorer by clicking on C: drive icon.

Now I know that there are several ways of opening gnome explorer, but I just couldn’t find them.

Anyway, note that I have two partitions and gnome explorer only showed me one of them. It appeared to me that something is wrong with D: drive and I should try to mount it. I went to Add/Remove programs and added a program called Disk Management. It seemed logical to me that I need some program that manipulates disks, so I searched for disk and found that Disk Management program. However, once I started it, it reported that I don’t have disks at all.

This was the breaking point. Playing around with Ubuntu was fun, but I had to stop and go back to the world of productivity – where at least sometimes things work.

Conclusion

Linux is a great operating system and like I mentioned I feel lots of respect to developers of Ubuntu and Linux for the job they are doing. This is especially true because I owe my income to Linux, for the last decade. Linux has given me a profession and I am grateful for that. However it seems that, regrettably, Ubuntu, one of the the undoubtful leaders among Linux distributions, is still too immature as a Desktop solution. Too many things are not obvious. Too many things just don’t work out of the box. Yes I could find a solution for everything, but I am just too busy person to search solutions for everything.

Related posts:

1. Is desktop Linux too fragmented to succeed?
2. What kept me from sticking to Ubuntu as a desktop solution
3. Few thoughts about Ubuntu servers and CentOS

IntroductionBACK TO TOC

This article extends optparse‘s documentation. optparse is a Python’s module that allows your program to easily parse command line options it receives. In addition, it takes care of some of the very common tasks, such as handling -h command line option.

optparse is one of those modules that are an absolutely must have for almost every project. However, because we start new project so seldom, it is difficult to remember all those recipes that we come up with, every time we add a new command line option. This article is an attempt to bring together such recipes.

optparse‘s official documentation lacks some very important information. On the contrary to official documentation, in this document I am trying to give you more hands-on kind of documentation. This article is a cookbook of things that you do with optparse most often.

What do we do with command line optionsBACK TO TOC

Every time we use optparse, we use it to do a number of things. Obviously we want our program to support command line options. What varies is the type of options we want to support. Some options doesn’t have additional arguments (boolean options). Others are mandatory. Some require one or more arguments. Finally, we may want options to depend on each other – i.e. we may want one option to depend on presence of another.

These are most common things that we would like to implement, but there are more. Lets try to build a list of all such functionalities that we may want to implement.

• Support for a standalone command line options (boolean options).
• Support for mandatory (required) options.
• Support for options with one or more arguments.
• Default values for options.
• Dependency between options.
• Grouping of options in help screen.
• Customizing help screen.

However, before we dig into implementation details of each and every one of these bullets, lets see the basics of using optparse.

optparse basicsBACK TO TOC

No matter what you do with optparse, it all starts with importing optparse and instantiating OptionParser class.

import optparse

parser = optparse.OptionParser()

Adding optionsBACK TO TOC

To add an option, we should use OptionParser‘s method called add_option(). It accepts a large number of parameters. For now, we will see only the most basic. We will see more advanced parameters later in this article. Note that we should call add_option() for every option that we would like our program to support.

Obviously the most important parameter tells what command line option we would like to support. Lets say that for sake of this article we would like our little Python script to support -n command line option. Also, we would like -n to have longer sibling –new. –new and -n would have the same meaning, but one is shorter and the other longer and more verbose.

This is how we add these options.

parser.add_option('-n', '--new')

Note that by all means this is not enough to be able to parse even simplest case of command line options. This is only the basics.

Specifying help string for an optionBACK TO TOC

One more thing that is very common when using optparse is to give a short help string that would tell user what this particular command line option does. optparse will print this string if user runs your program with -h.

To specify such help string pass parameter named help to add_option(). Like this:

parser.add_option('-n', '--new', help='creates a new object')

Telling optparse to parse argumentsBACK TO TOC

Once we’ve added all the options we want our program to support, we should tell optparse that it is time to do actual parsing. This is how we do it.

(opts, args) = parser.parse_args()

parse_args() method returns a tuple of objects. First object, opts, contains all values we’ve received via command line. We will learn how to use this later in the article.

args is a list of words that contain everything that left after options that parser recognizes. This is useful if you want your program to support indefinite number of arguments – like in cp or mv Unix commands, where you specify options first and then a long list of files to copy/move, followed by a destination directory.

Putting it togetherBACK TO TOC

This is how our script looks like so far.

#!/usr/bin/python

import optparse

parser = optparse.OptionParser()
parser.add_option('-n', '--new', help='creates a new object')

(opts, args) = parser.parse_args()

Running it with -h command line option, would produce following result.

alex ~/works/args -> ./args.py -h
Usage: args.py [options]

Options:
  -h, --help         show this help message and exit
  -n NEW, --new=NEW  creates a new object
alex ~/works/args ->

args.py is the name I had given to the script. Take this little nice help screen. Note that we didn’t do a thing to make it appear. This is where power of optparse begins.

optparse cookbookBACK TO TOC

What we saw until now were common things that you do with optparse to operate it. No matter what options you would like your program to support and what are relationships between the options, you have to instantiate OptionParser and have to call parse_args() method.

However, few methods that we’ve seen so far, are useless by themselves. We use them to do more specific things, which we will study in this section of the article.

Support for a standalone command line optionsBACK TO TOC

I call such options boolean options because eventually we want some boolean variable to indicate if optparse saw the option or not.

For the sake of the demonstration, lets say we want our script to support -b option. When this option is specified, we want some variable to be True. This is how we do it.

parser.add_option('-b', help='boolean option', dest='bool', \
    default=False, action='store_true')

(opts, args) = parser.parse_args()

Note three new named parameters that we’re passing to add_option(). dest specifies the name of the variable that will hold True or False value once optparse runs into -b. default specifies default value of the variable, in case optparse doesn’t find -b. Finally action tells optparse what to do when it runs into -b. store_true action tells optparse to place True value into bool once it detects -b.

Additional action that we may want to use called store_false. It tells optparse to set a value of bool to False. Note that when we use store_false, we better change default value to something other than False – otherwise you won’t be able to see the difference between when -b is there and it is not.

Once parse_args() finishes, you can access the variable via opts.bool. You can drop the default value of the variable. In this case, if you don’t specify -b command line option, value of opts.bool will be None.

Support for mandatory (required) options.BACK TO TOC

optparse itself doesn’t support mandatory options. As optparse‘s documentation states, mandatory options are a bad practice and should be avoided. However, I think that at the end, it is your choice to make and modules such as optparse should give you the tools to do things that you want to do. This said, this is what I usually do to have a mandatory option.

For a single variable, just don’t set default value for it and check if opts.<variable name> is None, after opt_parse(). Like this:

parser.add_option('-m', help='mandatory option', dest='man',
    action='store_true')

(opts, args) = parser.parse_args()

if opts.man is None:
    print "A mandatory option is missing\n"
    parser.print_help()
    exit(-1)

Obviously, when a mandatory option is missing, we want to do something about it. This can be anything of course, but most likely you want to tell about the mistake and print a help message. This is exactly what happens in lines 7-9.

But what if you have multiple mandatory options? Well, we can do exactly the same, but for several options. Lets have a look.

parser.add_option('-m', help='mandatory option', dest='man',
    action='store_true')
parser.add_option('-p', help='mandatory option', dest='pan',
    action='store_true')

(opts, args) = parser.parse_args()

# Making sure all mandatory options appeared.
mandatories = ['man', 'pan']
for m in mandatories:
    if not opts.__dict__[m]:
        print "mandatory option is missing\n"
        parser.print_help()
        exit(-1)

Here, we have two mandatory options: -m and -p. In lines 9-14, I build a list of all mandatory options (represented by their destination property name), run through the list and see if any of them is None. If so, it prints an error message, help message and returns.

Support for options with one or more argumentsBACK TO TOC

With optparse we can parse options with an argument and even several arguments. This is how we do it.

parser.add_option('-s', help='arguments', dest='opt_args', \
    action='store')

This example is somewhat different from what we’ve seen before. Here, use an action named store. This action, tells optparse to store option’s argument in specified destination member of opts.

How about having an option with two or three arguments. It is doable as well.

parser.add_option('-M', help='multiple arguments', dest='multi', \
    action='store', nargs=2)

As you can see, you can tell optparse how many arguments you want some option to support. To do this, we pass nargs parameter to add_option(). Its default value is 1. This is why we could omit it when we registered option with a single argument. However, if we need two or more options, nargs is a must.

In this case parse_args() will place all arguments in a tuple. I.e. after we run parse_args(), opt.multi will be a tuple containing all arguments that user has passed to our program.

Option destination typesBACK TO TOC

By default, all members of opts object will be strings. I.e. when you specify a destination for your argument, its type is string, by default. However, it doesn’t have to be this way. You can change the type of the destination variable for the argument by passing add_option() a parameter named type. Note that default type is string. Despite you can always convert string into anything you want, you can ask optparse to do it for you. This is how.

parser.add_option('-s', help='arguments', dest='opt_args', \
    action='store', type='int', default=10)
parser.add_option('-M', help='multiple arguments', dest='multi', \
    action='store', nargs=2, type='string')

Here we’ve specified int type for -s and string type for -M. Note default value of -s. It should be of the same type as option itself.

Also note -M. Although optparse turns two arguments into a tuple, it does not support different types for several arguments. So, when an option has multiple arguments, their type should be the same.

Dependencies between optionsBACK TO TOC

As with mandatory options, optparse does not give you much help setting dependencies between various options. If you still want to have some relationship between options, you have to implement it manually, after parse_args() is over.

Luckily this is not very difficult thing to do. Remember how we’ve implemented mandatory options? We can do the same here.

parser.add_option('-A', help='option A', dest='a',
    action='store_true')
parser.add_option('-B', help='option B', dest='b',
    action='store_true')

(opts, args) = parser.parse_args()

if opts.b and not opts.a:
    print "Option B requires option A\n"
    parser.print_help()
    exit(-1)

Here, option B requires option A. If B is there, but A is missing, script will produce an error message, print help screen and exit.

Help screen customizationsBACK TO TOC

Grouping optionsBACK TO TOC

optparse has a neat feature allowing you to group options. You can create as many groups as you want. Each group will have a short description that would appear on help screen. Also, you can use option groups to group options inside of your program, making it easier to understand and more readable. This is how you do it.

First, we create an option parser as we usually do.

parser = optparse.OptionParser()

Next we create a new options group.

group1 = optparse.OptionGroup(parser, 'Options group 1')
group2 = optparse.OptionGroup(parser, 'Options group 2')

Note that to create an option group, we have to specify parser that we will use and a short description of the options in this option group. The description will later appear in the help screen.

Now we should add the actual options. This time however, we add them to groups instead of adding them to parser.

group1.add_option('-t', help='group 1 option', dest='t', \
    action='store')
group2.add_option('-d', help='group 2 option', dest='d', \
    action='store')

add_option() method of class OptionGroup is exactly the same as add_option() method of class OptionParser.

Finally, we add groups to parsers and call parse_options().

parser.add_option_group(group1)
parser.add_option_group(group2)

(args, opts) = parser.parse_args()

Now, lets have a look at the help screen.

alex ~/works/args -> ./args.py -h
Usage: args.py [options]

Options:
  -h, --help  show this help message and exit

  Option group 1:
    -t T      group 1 option

  Option group 2:
    -d D      group 2 option
alex ~/works/args ->

See how -t and -d standout, each in its own group.

Changing programs usage stringBACK TO TOC

You can specify your own usage string. This is the first line of help screen. You do this by passing usage parameter to OptionParser constructor.

parser = optparse.OptionParser(usage='Usage: %prog <options>')

If we run this code, this is how our help screen would look like.

alex ~/works/args --> ./args.py -h
Usage: args.py <options>
.
.
.

As you can see, you can use %prog mnemonics inside of usage string. It will be substituted with the name of the program.

Telling option’s default valueBACK TO TOC

Another thing that you can do is specify default value of the option in its help screen. To do that you can use %default mnemonics inside of help string of an option. Like this:

parser.add_option('-w', default='hello', dest='t', \
    action='store', help='this one has a default value [%default]')

This will make help line in help screen for this option to look like this:

-w T        this one has a default value [hello]

Better argument descriptionBACK TO TOC

parser.add_option('-s', help='single argument', dest='single', \
    action='store')
parser.add_option('-M', help='multiple arguments', dest='multi', \
    action='store', nargs=2)

Lets have a look at how the help screen would look like for two options above.

  -s SINGLE          single argument
  -M MULTI           multiple arguments

Not a pretty sight. See how optparse described parameters that each option receives. In fact, optparse take this description from name of the destination argument. To generate such description, it converts its name into a string and changes it to upper case.

This may somewhat work for an option that receives one argument. But it certainly will not work for an option that receives mutliple arguments, such as -M. Luckily, there’s a solution for this problem. add_option() receives a parameter named metavar. It tells optparse how to describe option argument in help screen. So, instead of calling add_option() the way we did it for -s and -M, we should call it this way:

parser.add_option('-s', help='single argument', dest='single', \
    action='store', metavar='<ARG>')
parser.add_option('-M', help='multiple arguments', dest='multi', \
    action='store', metavar='<ARG1> <ARG2>', nargs=2)

This makes the help message for these two options look like this:

  -s <ARG>           single argument
  -M <ARG1> <ARG2>   multiple arguments

Now this is much better.

Adding program descriptionBACK TO TOC

You can have a description of what your program does. When having it, it will appear in help screen between usage line and options description. To do that, pass description argument to OptionParser constructor, when creating OptionParser object. Like this:

desc="""This is a description of %prog. optparse uses Python's
textwrap module to format the text, so
don't
bother
adding
new
line
characters, as optparse will prettify your description in
its own way."""

parser = optparse.OptionParser(description=desc)

parser.add_option('-s', help='single argument', dest='single', \
    action='store')

(args, opts) = parser.parse_args()

Running this little program with -h, will produce following help screen.

alex ~/works/args --> ./args.py -h
Usage: args.py [options]

This is a description of args.py. optparse uses Python's  textwrap
module to format the text, so  don't  bother  adding  new  line
characters, as optparse will prettify your description in its own
way.

Options:
  -h, --help  show this help message and exit
  -s SINGLE   single argument
alex ~/works/args -->

Note how optparse reformatted the description string. It uses Python’s textwrap module to format your description, producing nice, 80 character long lines of text.

Also note that as with usage parameter, you can use %prog mnemonics here. It will be substituted with name of your program.

Adding epilogBACK TO TOC

Epilog will appear after options description. To specify epilog, pass epilog parameter to OptionParser‘s constructor. Note that as with description string, optparse will prettify the text you use with textwrap.

Program version stringBACK TO TOC

Like help screen, optparse can also generate version string, responding to –version option. Unlike with help screen where optparse did most of the job, here optparse merely prints what you’ve specified as version string.

To specify version string, pass version parameter to OptionParser‘s constructor. You can use %prog mnemonics inside of version string. Here’s an example.

parser = optparse.OptionParser(version='%prog version 1.0')
(args, opts) = parser.parse_args()

Running this script with –version option, produces following result.

alex ~/works/args --> ./args.py --version
args.py version 1.0
alex ~/works/args -->

optparse produce version string only if you run it with –version option. If you want to your program to print its version with -v option, you will have to add -v option manually and then call print_version() method of OptionParser, to produce the version string.

ConclusionBACK TO TOC

There is a bunch of other things that you can do with optparse. You can have your own actions, your own formatter – an object that formats the help screen.  You can use callbacks that get called when optparse runs into certain option. However, I think I’ve covered 99.9% of what you may need. In case I missed something, send me an email to alex@alexonlinux.com.

No related posts.

IntroductionBACK TO TOC

Many wonder what is the real difference between 64-bit and 32-bit computers. Is paying a little extra for 64-bit support really worth it?

What 64-bit support mean?BACK TO TOC

This can mean many things actually. This article dedicated to recent (relatively of course) addition of the 64-bit support in AMD’s and Intel’s micro-processors. Processors supporting 64-bit calculations exists for many years. However these were industry class processors, very expensive and powerful. Couple of year ago, first AMD and then Intel began selling 64-bit processors designed with home user in mind. This historical change is the one I would like to review in this article.

What the difference between the 32-bit and 64-bit anyway?BACK TO TOC

Processors with 64-bit support are those that natively support operations with 64-bit long numbers – you need lots of bits to accommodate large numbers. You may be a little confused by the fact that built into both Linux and Windows calculators easily sum a pair of nearly every possible numbers, including a pair of very big numbers. The thing is that 32-bit CPUs only simulate calculations with large numbers.

In 32-bit computer, summing two 64-bit numbers takes 10 and even more times than summing two 32-bit numbers. On the other hand, in 64-bit computers summing two 64-bit numbers takes same period of time as summing two 32-bit numbers.

General purpose registersBACK TO TOC

Another, less obvious, difference between the two is that processors with 64-bit support has additional 8 general purpose registers – these are small pieces of memory that are built into processor itself and help it to do its job. Importance of the later addition often overlooked, however this is the change that has brought a truly significant performance boost to 64-bit processors over their 32-bit predecessors.

What additional registers good for?BACK TO TOC

Actually the CPU does most of its operations using registers. Registers work as fast as the CPU itself, while RAM is much slower. So in terms of performance, it is better to do as many calculations using registers as possible. The problem is however that having registers is very expensive.

Intel’s Itanim processors have 128 general purpose registers. Itaniums are an industry class processors and are very expensive.

Additional 8 registers is a significant addition that let the CPU to speed up some of its operations by a large margin.

So how good 64-bit really is?BACK TO TOC

With 64-bit extension you get 10% performance boost for free. This number can be different from system to system of course, but I think we can presume this is pretty much the average.

What about OS and software?BACK TO TOC

When you have some neat feature in your CPU, you need software uses it. This is why there are 32-bit operating systems and 64-bit operating systems. First knows nothing about 64-bit calculations and additional registers, while the later uses both of them all the time.

Same with regular software.

Does that mean that paying extra money for 64-bit Windows XP/Vista worth it?BACK TO TOC

It’s a bit complex. You cannot run 64-bit software on 32-bit operating system. So if you plan running anything that uses 64-bit, you will need 64-bit operating system.

Still for most of the users the answer would be negative. The problem is that most of the software for Windows is 32-bit. 64-bit versions are rarely available. You can run 32-bit software on 64-bit computer and 64-bit operating system, but buying 64-bit operating system is often useless because you may end up using 32-bit software all the time.

update: As Mr. rasmasyean kindly noted in the comments below, amount of physical RAM that you plan to have in your computer is another consideration that should be taken. 32-bit versions of both Windows XP and Windows Vista limit amount of supported physical RAM to 4GB. In case you need more RAM, you will need 64-bit version of Windows.

How about Linux?BACK TO TOC

Linux is completely different story. For most of the software there is a 64-bit version. Even if there is none, you can try to compile it yourself – it is not that complicated. And there is no difference between 64-bit and 32-bit operating system in terms of price. So go ahead, grab yourself a 64-bit Linux and enjoy its improved performance

Related posts:

1. Python’s optparse for human beings
2. Aligned vs. unaligned memory access

IntroductionBACK TO TOC

This short article deals with simple question. How exactly lack of swap partition affects Linux’s performance. What would happen if you turn the swap off?

The obviousBACK TO TOC

Memory leaksBACK TO TOC

The obvious price one would have to pay for turning the swap off is lack of so called virtual memory. The term virtual memory refers to several different things really. What I mean is that when a program leaks memory, the memory it has leaked will remain unused as long as the program still running.

On the contrary, when swap is on, operating system copies memory that is not in use to the swap partition, by that freeing actual memory. So when one of the programs has memory leaks, memory that being lost by the program finds its way to hard drive instead of continuing to take precious memory.

I never heart of a program that claims that it has no memory leaks. Every program looses memory. It is a matter of time until it will ran out of memory and then the program will crash. Swap is not an ultimate solution for this problem because swap space can run out too, yet it significantly prologues live of the individual processes and the overall system.

HibernationBACK TO TOC

It is being referred to as hibernation and perhaps few other ways. At the bottom line this is a method to fast turn on and off the computer.

Instead of turning off all services and programs and then initializing them again, operating system suspends execution of all processes, then writes all used memory to swap space and then turns off the computer.

When you turn your computer back on, instead of starting a brand new session from scratch, operating system restores memory from swap and resumes all programs that were running, without reinitializing them.

By the way, one of the reasons why recommended swap space size is twice the size of the RAM that is in the computer is to let the operating system to accommodate all your RAM in swap partition – to allow hibernation of course.

Obviously, when you don’t have swap partition, you cannot do hibernation anymore.

The less obviousBACK TO TOC

I/O cacheBACK TO TOC

Linux uses all available memory to do I/O cache – that is to save portions of the hard disk space and to serve it straight from the memory avoiding relatively long disk access. This is why for instance when you copy several large files from one place to another several times in a row, second copy takes significantly fewer time then the first. This is also the reason why, in Linux, it takes a second to write a megabyte to a floppy disk, a device known for its slowliness – the data being written to the memory and not to an actual disk.

Also, disks optimized to read and write large chunks of data. Average program on the contrary reads and writes small chunks of data. To speed up the process, Linux collects several small read and write requests into bigger thus increasing disk performance. This however requires memory.

What many people don’t realize is that Linux uses all available memory and always tries to free even more memory for caching. When it sees a piece of memory that some program did claim, but doesn’t use very often, it will copy it to swap partition and use the actual memory for caching. Once the program will try to do something with this memory piece, Linux will detect this and read the contents of the memory piece from swap partition back to the real RAM.

By the way, this is the reason why when you minimize a program and after a while restore it, it takes it a few seconds to become fully functional – Linux had moved pieces of its memory to swap partition and now this memory has to be restored. Reading data from disk takes more time than actual memory access, thus the delay you see when you restore the program. You can change how hard the operating system tries to free memory for cache by changing value in the /proc/sys/vm/swappiness. The value varies between 0 and 100. Value of 100 means that operating system will not wait much time to move memory to cache. Note that whatever swappiness value you have, Linux tries to keep your system stable and will move pieces of memory into cache if it thinks it is necessary.

The real issue here is that this mechanism should be very balanced. Linux is optimized to use all available memory for caching. When it doesn’t have enough memory, time it takes to access data on disks will rise! Since all programs leak memory, over the time Linux will have less and less memory for caching and disk access speed will drop.

Bottom lineBACK TO TOC

Bottom line is that, without swap:

1. Your system will be less stable.
2. Your system will not be able to hibernate.
3. Disk access speed in your system will be slower compared to a system that has swap partition. Moreover, disk access speed will drop in the course of time.

In case you have further questions, please email me to alexander.sandler@gmail.com.

Related posts:

1. What’s is direct I/O anyway?
2. Aligned vs. unaligned memory access
3. Backup and restore your Linux installation

Related posts:

1. Wow! My tcpdump for Dummies is on the front page of delicious.com

I decided to write this review for two reasons. First of all, although there are so many reviews out there, no one has tracked the device and its development or evolution for over a year. I did. Also, there is a personal story of using Irex Technologies Iliad that I would like to tell.

History

I started tracking development of e-Ink or e-Paper based devices sometime in 2002 or 2003, when I heart about this wonderful technology for the first time. The perspective of having screen with paper like DPI thrilled me. I am respectful to paper books, yet in terms of convenience and ease of use, analogue media already lost it to digital media in nearly every possible aspect. Consider MP3, personal media players with movie playing capabilities. Etc. Yet, the only direction in which digital media didn’t make much progress was reading and books. LCD screen based e-book readers lack many features that are a must in devices of this kind: readability, battery power, etc. As far as readability concerned, I assume either you yourself experienced headache or heart about people suffering from this problem when reading from LCD screen. Not to mention endless problem of reading at sunlight. On the other hand constantly emitting light, like LCD screens do, causes high power consumption, thus rises requirements for the power source – the battery. Problem of power consumption is even worse when combined with reading at sun-light issues.

Considering this, no wonder LCD screen based e-book readers didn’t take off. What about other technologies, you may ask? There is no monitor technology that would be suitable for intensive reading. On the contrary, other technologies are even more problematic then LCD. Something had to change and it did. With introduction of e-Ink screens.

A word on technology

I don’t want to dig too deeply into technical details of how things work in e-Ink screens. Yet at least on paper the idea is quiet simple. Screen consists of positively charged dark particles and negatively charged white particles. Charge applied to one side of the screen. Positive charge draws negative particles, pushing positive particles to the other side of the screen. Same thing, with opposite polarity, happens when applying negative charge.

Irex Technologies Iliad

After waiting for several years for the new dream gadget, such gadgets finally began to appear. At first it was Japan only. Irex Technologies, a Philips spin off, was the first firm to release e-Ink based device in Europe. Few month after its initial release it became available in the middle east and I couldn’t wait any longer. It cost me almost 900$ including taxes, delivery and customs to Israeli authorities that didn’t know how to handle the device and detained it until I payed another 60$ and explained them myself what the hell is this. I didn’t think about the price. I had to get one and I did it.

First impression

At first, I was astonished by simplicity of packaging. Cool looking box contained only three items – USB cable, charger/USB/Ethernet hub and the device itself. I expected to see a manual, yet it wasn’t there. After thinking about it, I concluded that all documentation should be in the device itself. After all, this is a device for reading texts.

So, I decided to turn it on and see for myself. My first guess was that On/Off button is the big round button in the right top corner, yet after pushing it for a while I concluded that either the device is broken or the On/Off button is somewhere else. This is when I thought that it still might be a good idea to see a manual before turning it on. Luckily I was next to a computer. I browsed to Irex’s web-site and downloaded the manual. It appeared that power button is not the round button in the right top corner but a little needle at the bottom edge of the device. After I pulled it, the screen blinked and I saw the e-Ink technology in action for the first time in my life.

I must say that it is one amazing technology. Well you can see the pixels, but they are small. And by small I mean really small. You can see the text under any angle and it does look like paper. The surface color is bright grayish beige. The darkest black appears as dark gray color.

The device has a resolution of 1024×768 pixels. And since the screen size is only 8 inch (diagonal) you get nice around 160 DPI (Dots Per Inch). This is twice more then you have on a regular LCD panel and you enjoy every dot per every inch out of it

Second impression

After playing around with the device, I decided to see what kind of settings are available for me. The device’s user interface is very intuitive so it didn’t take me much time to figure out where are the goodies. It appeared that software version installed on my Iliad was 2.5, despite specs on the package clearly stated that it is 2.6. Moreover, the Irex’s web-site stated that all new units sold with 2.6. And what’s the first thing you do with a gadget when you know that newer version of software is available? Of course, you upgrade. So did I.

I configured wireless network, plugged it into power hub and did a long press on the connect button (the button in the right top corner – more on buttons later). Upgrade went almost smoothly. The only problem was that I had to retry the installation twice – first time it got stalled and I had to reset. My prayers were answered because after the reset it booted with good old 2.5. Second attempt went so much better and I ended up with brand new 2.6.

Third impression

After reading few documents that were already on the device (readme, release-notes, etc ), I decided its time to try some of my own content. I had latest Intel’s x86 PDF specs and I decided to give them a try. I’ll spear you a story of what happened during next couple of hours. I think you can make a guess yourself, knowing that USB cable I received with the device wasn’t good and I had to use my own – luckily, it is a standard USB to square-USB cable. So after few hours long headache I was finally reading my beloved x86 spec.

Well… When you think about it, it really shouldn’t surprise anyone. I mean PDFs made for A4 paper will not render well on a A5 screen. Yet, it was some sort of disappointment. On the other hand it really has nothing to do with Iliad, since most of the e-Ink based devices have relatively small display. Later, Irex partially solved this problem by adding zoom in feature in PDF viewer.

Something that draw my attention immediately after I turned it on was the fact that it takes so much time for it to boot. I mean my PC usually boots faster then Iliad. By much time I mean 40 seconds, more or less. I’ve seen people wondering if this will ever change and prognoses on this are quiet pessimistic. More on this later.

Features overview

Now let’s say few words about Iliad’s features. After all Irex always claimed Iliad is business oriented device, thus it should be packet with lots of stuff. And actually, it is:

1. Support for several different formats, PDF, HTML, Mobipocket, etc.
2. Supports MP3 and has audio jack. The only problem with this feature is that they never implemented it. More on this later.
3. Touch screen – correct me if I am wrong, but this is the only e-Ink device with touch screen at the moment. More on this later.
4. Wi-fi, ethernet and USB connectivity.
5. MMC/SD and CF (I/II) slots for more memory.
6. Exceptionally (for this kind of devices) powerful CPU (xScale at 400MHz).
7. 64Mb of RAM and 128Mb of internal memory.

Unfortunately, as I mentioned, MP3 support actually never appeared. HTML is indeed supported but only few languages supported (actually this is something that changes so keep up with the updates). This is a serious problem for someone who reads other languages, such as myself.

Touch screen is nice, but here’s something that Irex never mention when they advertise Iliad. e-Ink is quiet slow. Meaning that no matter what you draw, it will appear something like 0.5-1 second after you drew it and this is really annoying. In my case, it is so annoying, I stopped using Iliad for sketching and writing almost immediately, despite I hoped it would become a replacement for my paper note book that I often use.

You can easily guess why you need USB connectivity but Wi-Fi and Ethernet? At the moment, the only feature that uses Wi-Fi and Ethernet is downloading firmware updates. Otherwise it is completely useless. Now obviously there is a reason why Iliad has them, but year and half after Iliad was introduced for the first time, we still can only speculate. One possible reason is that Iliad going to let you browse Mobipocket book catalog and buy stuff right from the device. We will see.

Of course you need a memory card slot. Of course you don’t need two slots. You could argue that some people may not have MMC/SD or CF card and having two cards is convenient, but truly, do you know a person that doesn’t own a MMC/SD card?

Finally, I simply cannot explain why there’s so powerful CPU in it? You could argue that Irex probably are going to add more features that will raise the CPU consumption, but nothing like this happened since Iliad was released for the first time. And I doubt it will ever happen. Actually, after reading release notes each time they released a software upgrade, I noticed that Irex spent great deal of time trying to keep the CPU running at 100MHz most of the time (to reduce power consumption). Go figure.

Having too powerful CPU, useless Ethernet and Wi-FI controllers, useless memory card slot and a touch screen skyrockets the price for the device. No wonder this is one of the most expensive e-Ink based devices at the moment.

The backside thing

Take a look at the picture. What is that you see on it? This is a backside of 1st edition of Iliad. The backside seems to be designed for some stand or holding device. Yet, there is no holding device, neither stand for Irex Iliad.

Moreover, in September 2007 Irex announced a new edition of Iliad. Let me quote “The iLiad 2nd edition features a fully redesigned backside that looks more elegant and also provides more stability when the iLiad is laying on a surface”.

Now I must say that this whole backside thing sounds, smells and looks like a complete joke. I suppose there are things that you can do with backside of the device. Things like placing retractable leg that would let to have Iliad standing and not laying. Yet these features bypassed Iliad. Instead it features useless backside design that was redesigned in 2nd edition. Unfortunately, I couldn’t find pictures of the backside of 2nd edition.

Buttons

One of the things Irex advertise is the flip button used to turn pages. I certainly agree that the button is indeed very convenient. Yet, it may start getting jammed a bit, sometimes causing Iliad to interpret single press and a long press turning five pages instead of one. And it is exceptionally annoying if all you wanted to do is to turn to a next page and instead you jump five pages ahead and try to get back, page by page, but then suddenly it jumps five pages back and eventually you flip two pages back instead of one page forward (other combinations are possible, taking you to any page within ten pages range but not to the next page). Can’t tell if this is a software or a hardware problem. Also I can’t tell you if it will happen to you too. It did happen to me.

Other buttons are handy. I suppose you’ve seen them on pictures. There are four dedicated buttons that take you to different sections of device’s memory – the news, books, docs and notes buttons. You can configure a folder to which you’ll be taken once you press any of these buttons. Pressing any of these buttons twice will take you to the last document you’ve read from that category.

Below the flip button, there’s a next and prev buttons and the enter button. Above the flip button there’s a menu button that takes you to main menu of the device and a up button that takes you to higher level in the menu.

You are probably wondering what’s next and prev buttons needed for. After all, there’s a flip button. Actually, next and prev complement the flip button. In menu, flip button allows you to step over pages of menu items (six items per page), while next and prev buttons allow you to walk through menu item after item.

The power button is a completely different story. It is exceptionally inconvenient. You really must to have your fingernails in good shape to turn Iliad on. Furthermore, not only you have to reach that needle, but you also have to hold it pressed for a second or two. There is absolutely no chance of pressing it accidentally. Yet you still have to hold it pressed to turn the device on. This is perhaps the most annoying imperfections that Irex afforded to have.

Software

Irex Iliad is a Linux based device. It’s interface built using, believe it or not, X windows toolkit. From one point of view it should ease software development. From the other point of view, it gives the interface slightly oldish look and feel – considering the monochromatic nature of the device it might be an advantage.

The Iliad’s interface is relatively well thought. There are eight items in the main menu

1. Iliad Settings
2. Iliad Profiles
3. Reference Materials
4. Recent Documents
5. CF Card
6. MMC Card
7. USB Stick
8. Main Memory

As I already mentioned there are four dedicated buttons that take you into news, books, docs or notes folders in either CF card, MMC card, USB stick or main memory (default). You can also use the main menu to get to one of these.

Anyway, things seems to be good more or less. The only thing that I didn’t like was the operation of the menu itself. First it is too bulky on the screen. There is absolutely no reason to limit number of items appearing on such a large screen to six – compare with Sony PRS-50X, pressing tens of items onto smaller screen. Other thing that I didn’t like very much is that the menu is so slow. I mean with so much RAM and CPU power, Iliad could draw in memory every possible menu item long before I attempt to access it and only show a picture once the menu is accessed. Instead it takes over a second, and sometimes even more, to open a menu item.

On the other hand, Irex tend to solve this kind of problems and in this particular case I think it will be solved at a time.

Ergonomics

One of the problems with all e-Ink based devices that I’ve seen is that they are not comfortable to hold. Despite this device is mostly hand held, Iliad in particular doesn’t have much space for a grip. This is bad for people with big hands, such as myself. Iliad is also not very comfortable for people with small hands because it is quiet heavy. It seems that Irex didn’t put too much effort into thinking about how people going to hold it.

This emphasizes the negative impression I got when was looking for power button. As far as ease of use and ergonomics concerned, Irex could do a much better job.

To complement this, I admit that I didn’t see other companies placing too much effort into solving this problem.

The power thing

Irex are doing excellent job keeping the device working for as long as possible. Also, this is one of the issues that improves over the time. When I received Iliad it was working for 6-8 hours. Now, with version 2.11 it’s supposed to be 12. Yet, just to make things a little bitter I must remind that Irex were selling 20 hours non-stop. They are no longer advertising anything like this today, but this is what I payed for.

Still, having a device like this working for 10 and even more hours straight is almost too much to ask.

The boot time thing

Iliad boots in 40 seconds. This is absolutely awful. Perhaps they’ve planned people having Iliad on for whole day. I don’t know. I was mostly using it for periods from couple of minutes, to couple of hours and while in later case waiting 40 seconds for it to boot is more or less acceptable, waiting 40 seconds just to read for two minutes (or actually what have left from them), is too much.

I encountered several discussions regarding this issue on different forums on the web. The final verdict, told by the Irex themselves, was that it is impossible to shorten boot time. This is mostly due to amount of hardware devices on board that have to be initialized. Also it is impossible to implement suspend/resume features because hardware was never designed for something like this. I am not sure this is completely true, there is nothing we can do about it. 2nd edition of the device didn’t bring so awaited salvation. 40 seconds boot time it is.

Upgrades

Once in couple of months Irex releasing a new version of software for Iliad. Although it usually brings nothing exceptionally new to your Iliad experience, most of the time it does include nice improvements here and there. Over the time, Iliad’s battery life got better. New features, such as zoom in that I already mentioned and landscape mode, had appeared. It now supports Mobipocket, which is a very nice addition to the overall feature set.

One of the things that significantly improved Iliad experience was an improved PDF viewer page rendering time. As I mentioned e-Ink screens are very slow. It takes it almost a second to redraw itself. Irex did software changes to make this process much faster.

SDK for Iliad

One of the things Irex promised and accomplished was a release of SDK for Iliad. Iliad is Linux based device, running Linux kernel 2.4. It took them some time, but eventually the SDK is here and the results can already be seen – take the Sudoku game for Iliad for example.

The release of SDK makes me believe that MP3 support will arrive – and if Irex won’t add mp3 support, someone else will do it for them.

Last time I checked there were some problems installing home brew Iliad software – this process isn’t standardized yet. However things are changing and I believe more home brew software will appear and it will be much easier to install it.

Technical support

I applied for technical support twice. In both cases it was exceptionally slow and tedious process.

I’ve heart about people who were luckier then me. I think it depends on how you buy it and if there is a local distributor in your country. If you’re wondering how’s tech. support in your country, you better check on local forums and see what people are saying.

In case there is no local distributor in your country and you intend to buy directly from Irex, the technical support process is awful. If something goes wrong with your Iliad and it has to be repaired they send you a special box. You should place your Iliad into the box and send it back to them. Then, few weeks later they will send you a replacement unit. No, they won’t repair your unit. They will send you someone esle’s, repaired unit. And they won’t delete information from your Iliad before sending it to someone else, so make sure you don’t have any sensitive information on Iliad before sending it to repair. In addition you may run into problems with your local tax authorities – most likely they have no idea what’s Irex Iliad and why you and Irex Technologies LTD. want to exchange expensive goods without paying any customs.

I did it twice (see “Iliad vs. me” below) and in both cases the whole process took month and half.

Their technical support personnel isn’t exactly listening to you (reading your emails). Once they understand what’s the problem, they follow a procedure. They have procedures for every occasion and they will follow the procedure ignoring any of your attempts to speed things up. And you do want to speed things up because it is really slow.

Finally, luckily, it won’t cost you money (except for customs) if your Iliad is on warranty. Otherwise you will have to buy a “Repair Voucher” that can be as much as 112$.

Conclusions

I think I covered most of the interesting aspects of Irex Iliad. In my opinion the technology is absolutely amazing. Yet so far Irex Iliad failed to deliver what they sell. Perhaps this can be compensated by the fact that the technology is so new. Hopefully one day they will overcome the problems that Iliad has and it will become a killer device. They are making some progress (although I am not sure that the direction is right). In the meantime it is up to you to device whether to spend your money on the device.

Iliad vs. me.

As a post script to this review, I would like to tell you what have happened to me personally.

I bought Iliad a second after it became available here, in Israel. Payed for it a small fortune. At first I liked it very much, but after two months two horizontal stripes appeared in the middle of the screen. The stripes didn’t disappear when device was turned on and off. I ignored them, but then they became wider and eventually I had to apply to Irex’s technical support.

It took two months to complete box/replacement unit cycle. Most of them I spent without Iliad, reading books from my old pocket PC. I payed 30$ to Israeili customs authorities when I received the box for the first time – this is because they decided to check what kind of item costs 1$ and detained it. I had to pay 30$ storage fee (when they detain things, they store them).

I asked technical support, several times, what caused this problem and if there is a way to avoid this problem in the future. They ignored all my questions.

There was one problem with the replacement unit – the stylus for the touch screen was very loose in its slot. It was falling off its slot when you simply upended Iliad. I thought it is nothing, until one day I lost it. You can use Iliad without a stylus if you only need it for reading, but there are some things that require that darn stylus. For instance, you can’t change network settings without it.

I decided not to buy a new stylus because it was simply too expensive. Consider paying 50$ for piece of cheap plastic crappy stylus that you are going to loose anyway. It is cheaper now. Only 30$. Yet still too expensive for me.

Three months after I received a replacement unit, once again, a horizontal stripe appeared in the middle of the screen. It widened with time, so I applied for technical support again. This time I wasn’t too patient and got almost blunt in my emails to them. Don’t know if it has anything to do with my bluntness or it was bad luck, but this time, the cycle took months, again.

Replacement unit I received obviously wasn’t configured to work with my home wireless network. Since I didn’t have a stylus to configure it, I got stacked with version 2.10 of the software. Still, I kept using it, until three months ago vertical stripe appeared in the middle of the screen. This time the 1 year warranty was over so I decided not to apply for technical support but to write this review instead.

At the moment I’m saving some money to buy myself a new ebook reader. Didn’t decide which one to buy yet, but it certainly won’t be Irex Technologies Iliad.

I hope you found this article useful. Fill free to leave comments.

Alexander Sandler.

Related posts:

1. g15dods
2. Hall of fame