Mits Log

How to format a drive on Linux

2011-06-15T20:34:00.008+03:00

parted : Partition manipulation program

mkfs.ext2 : Create an ext2 filesystem
mkfs.ext3 : Create an ext3 filesystem
mkfs.ext4 : Create an ext4 filesystem
mkfs.vfat : Create a FAT filesystem
mkntfs : Create a NTFS filesystem

e2label : Change the label on an ext filesystem
ntfslabel : Change the label on an NTFS filesystem

Display the mounted filesystems table

df

Unmount the device as necessary

sudo umount /path/to/device

Create an Ext3 filesystem

sudo mkfs.ext3 /dev/sda1
sudo e2label /dev/sda1 MyDrive

Create a FAT filesystem

mkfs.vfat -F 32 /dev/hda1

The option "-F 32" indicates FAT32.

Create an NTFS filesystem

sudo mkntfs /dev/sda1
sudo ntfslabel /dev/sda1 MyDrive

Styling form fields and buttons

2011-05-23T13:42:00.003+03:00

Although HTML form fields and buttons seem similar, in markup and basic style properties, they behave differently when it comes to defining their size. For example:

<input type="text" value="Text" />

<input type="submit" value="Submit" />

Both have static position and inline display. Now we set to both elements the following style: "border: 0; height: 30px; padding: 10px;". The text field behaves like a block element, i.e. respects the exact given height and padding. The submit button, however, treats the height as an outer total size and subtracts the padding, i.e. results to having height equal to 10px.

Linux reminder

2011-05-18T12:45:00.007+03:00

ps -e
All processes.

PID TTY          TIME CMD
    1 ?        00:00:01 init
    2 ?        00:00:00 kthreadd
    3 ?        00:00:00 migration/0
    4 ?        00:00:00 ksoftirqd/0
    5 ?        00:00:00 watchdog/0
 2497 tty4     00:00:00 getty
 2498 tty5     00:00:00 getty
 2501 tty2     00:00:00 getty

ps -eH
All processes, hierarchical.

PID TTY          TIME CMD
    2 ?        00:00:00 kthreadd
    3 ?        00:00:00   migration/0
    4 ?        00:00:00   ksoftirqd/0
    5 ?        00:00:00   watchdog/0
    1 ?        00:00:01 init
 2497 tty4     00:00:00   getty
 2498 tty5     00:00:00   getty
 2501 tty2     00:00:00   getty

ps -ef
All processes, full format.

UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 09:50 ?        00:00:01 /sbin/init
root         2     0  0 09:50 ?        00:00:00 [kthreadd]
root         3     2  0 09:50 ?        00:00:00 [migration/0]
root         4     2  0 09:50 ?        00:00:00 [ksoftirqd/0]
root         5     2  0 09:50 ?        00:00:00 [watchdog/0]
root      2497     1  0 09:50 tty4     00:00:00 /sbin/getty 38400 tty4
root      2498     1  0 09:50 tty5     00:00:00 /sbin/getty 38400 tty5
root      2501     1  0 09:50 tty2     00:00:00 /sbin/getty 38400 tty2

PID files

A pid file is kept in /var/run and is called by the name of the executable, plus a .pid extension. It contains the process id of the executable, which is the same thing ps will tell when it lists it. Generally, programs which use pid files create one when they start, remove it when they quit.

Search and Destroy files

find <dir> [-type {f|d}] -name <name> -print0 | xargs -0 rm -r -f

Search & Execute command on the same folder as the file

find <dir> [-type {f|d}] -name <name> -execdir <command> '{}' \;

Java reminder

2011-04-22T14:30:00.003+03:00

Enums

Because there is only one instance of each enum constant, it is permissible to use the == operator in place of the equals method when comparing two object references if it is known that at least one of them refers to an enum constant.

An enum type is implicitly final unless it contains at least one enum constant that has a class body. In any case, it is a compile-time error to explicitly declare an enum type to be final.

Nested enum types are implicitly static. It is permissable to explicitly declare a nested enum type to be static.

Interfaces

Every field declaration in the body of an interface is implicitly public, static, and final. It is permitted to redundantly specify any or all of these modifiers for such fields.

Every method declaration in the body of an interface is implicitly abstract, so its body is always represented by a semicolon, not a block.

Every method declaration in the body of an interface is implicitly public.

Nested Interfaces

Member interfaces are always implicitly static so they are never considered to be inner classes.

Maven + GWT

2011-01-30T23:31:00.008+02:00

This is how to setup a GWT project with vanilla Maven, i.e. using no plugins other than the built-in antrun.

1. Add GWT dependencies into the Maven POM file:

<dependency>
 <groupId>com.google.gwt</groupId>
 <artifactId>gwt-user</artifactId>
 <version>2.2.0</version>
 <scope>provided</scope>
</dependency>

<dependency>
 <groupId>com.google.gwt</groupId>
 <artifactId>gwt-dev</artifactId>
 <version>2.2.0</version>
 <scope>provided</scope>
</dependency>

2. Configure ANT-RUN plugin into the Maven POM file:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-antrun-plugin</artifactId>

 <!--
  Configuration for gwt development mode.
  It doesn't take part into the default build-lifecycle.
  You have to fire it, explicitly, from the command line:
  e.g. mvn clean compile war:exploded antrun:run
 -->
 <configuration>
  <tasks>
   <property name="classpath" refid="maven.compile.classpath" />
   <property name="src.dir" value="${project.build.sourceDirectory}" />
   <property name="war.dir" value="${project.build.directory}/${project.build.finalName}" />
   <property name="gwt.module" value="package.EntryPoint" />
   <property name="gwt.url" value="index.jsp" />
   <ant target="gwt.debug" />
  </tasks>
 </configuration>

 <!--
  Configuration for gwt compile mode.
 -->
 <executions>
  <execution>
   <phase>prepare-package</phase>
   <configuration>
    <tasks>
     <property name="classpath" refid="maven.compile.classpath" />
     <property name="src.dir" value="${project.build.sourceDirectory}" />
     <property name="war.dir" value="${project.build.directory}/${project.build.finalName}" />
     <property name="gwt.module" value="package.EntryPoint" />
     <ant target="gwt.compile" />
    </tasks>
   </configuration>
   <goals>
    <goal>run</goal>
   </goals>
  </execution>
 </executions>
</plugin>

3. Setup ANT build file:

<project name="project.name">

 <path id="gwt.classpath">
  <path path="${classpath}" />
  <pathelement location="${src.dir}" />
 </path>

 <target name="gwt.compile">
  <java classname="com.google.gwt.dev.Compiler" fork="true">
   <classpath refid="gwt.classpath" />
   <arg line="-war ${war.dir} ${gwt.module}" />
  </java>
 </target>

 <target name="gwt.debug">
  <!-- com.google.gwt.dev.HostedMode for legacy GWT 1.x -->
  <java classname="com.google.gwt.dev.DevMode" fork="true">
   <classpath refid="gwt.classpath" />
   <!-- http://java.sun.com/javase/technologies/core/toolsapis/jpda/ -->
   <jvmarg value="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=localhost:8000" />
   <arg line="-war ${war.dir} -startupUrl ${gwt.url} ${gwt.module}" />
  </java>
 </target>

</project>

Objective-C reminder

2010-12-28T04:12:00.006+02:00

typedef struct objc_object {
    Class isa;
} * id;

SEL

typedef struct objc_selector * SEL;

IMP

typedef id (* IMP) (id self, SEL _cmd, ...);

BOOL

typedef signed char BOOL;
#define YES (BOOL) 1
#define NO  (BOOL) 0

The Objective-C Programming Language
Objective-C Runtime Reference
F.A.Q. - comp.lang.objective-c

Initializing arrays in C

2010-11-28T18:20:00.009+02:00

Allocating an array at compile time is done using an initialization list. We can get the array size and length as the compiler knows that our pointer is pointing at an array block.

const char* car[] = { "foo", "bar" };

int car_size = sizeof(car);
int car_length = car_size / sizeof(void*);

Allocating an array at runtime is done using malloc. This time the procedure is reversed because the compiler does not know that we are dealing with an array pointer. We start by specifying the length and size and then move on to allocate and initialize memory.

int rar_length = 2;
int rar_size = rar_length * sizeof(void*);

const char** rar = malloc(rar_size);

rar[0] = "foo";
rar[1] = "bar";

Creating custom, lazily rendered, GWT components

2010-10-21T23:47:00.006+03:00

Unlike other UI toolkits, GWT components do not define some sort of a render() method in which they generate their DOM structure. Instead, in the majority of cases, they do that inside their constructor. Having the root element setup right after the constructor is sort of a soft requirement as most operations assume just that.

Built-in GWT widgets do not face hurdles with such architecture as they tend to be spartan in their structure. In most cases, they are essentially a high level API around basic HTML elements. However, this does not hold true when you try to build complex widgets, especially if they have to support lazy rendering.

The simplest approach of creating a complex widget is to extend the Composite class, setup a hierarchy of widgets linked together via standard HasWidgets operations and finally call initWidget() - all inside the constructor.

A less simple approach is to have inner widgets linked only at the DOM level. In such a case, the parent takes responsibility to create and attach manually the children's element, again inside the constructor. Additionally, the parent has to override doAttachChildren() and call for each children onAttach(). This is necessary because the parent-child relationship exists only at a "physical" level, not "logical". An example of this is DialogBox and its Caption inner widget.

Finally a more complex example is to have inner widgets and also support lazy rendering. An example would be, creating the children conditionally depending on configuration that becomes available after the parent widget has been created. For example consider the following:

MyDialogBox dialog = new MyDialogBox();
dialog.setClosable(true);
dialog.show();

You might not want to create the close Button, unless the closable flag has been set to true. To do so, MyDialogBox may override the onLoad() method, which will be called right after the component becomes attached to the document, and create the button lazily. For example:

class MyDialogBox extends DialogBox {

  @Override
  protected void onLoad() {
    super.onLoad();

    if (isClosable()) {
      Element topCenterInner = getCellElement(0, 1);
      topCenterInner.insertFirst(getCloseButton().getElement());
      adopt(getCloseButton());
    }
  }
}

Notice that no overriding of onAttachChildren() or doDetachChildren() is necessary here. The call of adopt(child) will trigger the child's setParent(), which will also trigger onAttach(), because of it's parent being attached to the document.

GWT component lifecycle

2010-09-28T22:57:00.013+03:00

Efficient use of GWT requires good understanding of it's component lifecycle. So here are some important rules:

The constructor always initializes, at least, the root DOM element.
The attachment of a child to a parent widget, also causes binding at the DOM level. The former is referred as "logical attach" while the latter as "physical attach". Both are being handled by the parent - see add() and remove().
When the parent is attached to the document, onAttach() will be called. Note that overriding the this method, based on documentation, is not recommended. Instead, doAttachChildren() and onLoad() are callbacks that may be overriden.
The doAttachChildren() will recursively call the onAttach() of any child-widgets. Overriding is required, for the cases where sub-widgets are attached to their parent at the "physical" level but not at the "logical" level.
A similar operation flow, but in reverse order, takes place upon detaching a child from a parent widget.

Widget, Panel, SimplePanel

Initializing class value member with C++

2009-12-07T20:00:00.005+02:00

#include <iostream>

class Bar
{
    public:
    Bar() {
        std::cout << "Bar constructor { this: " << this << " }" << std::endl;
    }

    Bar(const Bar& ref) {
        std::cout << "Bar copy constructor { this: " << this << ", ref: " << &ref << " }" << std::endl;
    }

    Bar& operator=(const Bar& ref) {
        std::cout << "Bar assignment operator { this: " << this << ", ref: " << &ref << " }" << std::endl;
        return *this;
    }
};

class Foo
{
    public:
    Foo(const Bar& bar) : m_bar(bar) {
        std::cout << "Foo constructor" << std::endl;
    }

    void doStuff() {
        std::cout << "Foo doStuff" << std::endl;
    }

    private:
    Bar m_bar;
};

int main(int argc, char* argv[])
{
    Foo(Bar()).doStuff();
    return 0;
}

How to extract audio from video on Ubuntu Linux

2009-11-15T12:40:00.006+02:00

Extracting audio from video on linux is easy; however it can be very time consuming searching for the right packages to install and then going through the myriad of command options.

First we need to install the FFmpeg package. We may also need to install the LAME package too.

sudo apt-get install ffmpeg
sudo apt-get install lame

In the simplest case we can use only ffmpeg like this:

ffmpeg -i invideo.mp4 outaudio.mp3

This however will encode by default the output at only 64kb. We can set a higher bit rate by using the -ab parameter like this:

ffmpeg -i invideo.mp4 -ab 128 outaudio.mp3

This will encode the output at a constant 128kb rate. We may set it up to 320kb for the better quality.
Finally we can use ffmpeg together with lame for a finer control of the encoding process.

ffmpeg -i invideo.mp4 outaudio.wav

This will extract the output without any encoding (raw pcm). Now we can encode the mp3 with lame in any way we like.

lame -m s -h -b 128 output.wav out.mp3

This will encode output.wav using stereo mode, high quality algorithm and a constant 128kb rate.

lame -m s -q 2 -V 4 -b 128 -B 320 output.wav out.mp3

This will encode output.wav using stereo mode, high quality algorithm and a variable 128kb minimum / 320kb maximum rate.

James Gosling must be loving the Go language

2009-11-14T19:06:00.005+02:00

Google introduced Go earlier this week, their very own programming language. Go looks like a good mixture of languages like C, Java and Pascal. It is a statically typed, native compiled language. It also supports modern features like garbage collection and concurrency fro the get-go.

The most interesting part of this new language, in my opinion, is its approach on object orientation and polymorphism. Here is what the FAQ says:

Is Go an object-oriented language?
Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy. The concept of "interface" in Go provides a different approach that we believe is easy to use and in some ways more general. There are also ways to embed types in other types to provide something analogous—but not identical—to subclassing. Moreover, methods in Go are more general than in C++ or Java: they can be defined for any sort of data, not just structs.

Also, the lack of type hierarchy makes “objects” in Go feel much more lightweight than in languages such as C++ or Java.

How do I get dynamic dispatch of methods?
The only way to have dynamically dispatched methods is through an interface. Methods on structs or other types are always resolved statically.

At this point I recalled James Gosling, the creator of Java, saying on an interview that if he were to recreate Java, he would make it a delegation-only language. I searched a bit and I found the relevant pieces. So here they are:

James Gosling on Java, May 2001

Bill Venners: When asked what you might do differently if you could recreate Java, you've said you've wondered what it would be like to have a language that just does delegation.

James Gosling: Yes.

Bill Venners: And we think you mean maybe throwing out class inheritance, just having interface inheritance and composition. Is that what you mean?

James Gosling: In some sense I don't know what I mean because if I knew what I meant, I would do it. There are various places where people have completed delegation-like things. Plenty of books talk about style and say delegation can be a much healthier way to do things. But specific mechanisms for how you would implement that tend to be problematic. Maybe if I was in the right mood, I'd blow away a year and just try to figure out the answer.

Bill Venners: But by delegation, you do mean this object delegating to that object without it being a subclass?

James Gosling: Yes -- without an inheritance hierarchy. Rather than subclassing, just use pure interfaces. It's not so much that class inheritance is particularly bad. It just has problems.

James Gosling on Java, May 1999

Bill Venners: In Java you included multiple inheritance of interface, but left out multiple inheritance of implementation. Were you trying to say anything to designers by making the interface a separate construct? Were you trying to say anything by leaving out multiple inheritance of implementation? How did that come about?

James Gosling: It listened to people from the C++ and Objective-C camps, and I tried to sort out who had the most happy experiences. The Objective-C notion of a pure interface with no implementation seemed to have worked out really well for people. It avoids a lot of the sticky issues such as disambiguation that people get into in C++. It's still kind of messy. It's an area that I don't feel totally happy with.

Bill Venners: In what way?

James Gosling: Another way for doing these things is a technique called delegation. Some ideas in the delegation camp felt good, but I never came up with anything that really worked. I ended up with the interface construct, which felt simple enough to be comprehensible, sophisticated enough to be useful. It also avoided any of the tar pits that the other folks got into.

How to setup a static IP on Ubuntu Linux

2009-08-05T22:02:00.006+03:00

Lets say we want to set our IP address to 192.168.1.100:

First we have to edit /etc/network/interfaces and change it from something like that:

auto lo
iface lo inet loopback

to that:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
address 192.168.1.100
netmask 255.255.255.0
gateway 192.168.1.254

Then we also have to edit /etc/resolv.conf, which is responsible for our DNS entries, to something like that:

nameserver 194.219.227.1
nameserver 193.92.150.3

Finaly we have to apply our changes by executing:

sudo /etc/inid.d/networking restart

How to create an ISO image from a CD on Linux

2009-07-04T19:04:00.006+03:00

Another mini Linux HOW-TO. I am writing these mostly for myself :)

1) un-mount the cd
2) dd if=/dev/cdrom of=/home/.../cd.iso

Flexible Repository 2

2009-01-03T23:08:00.050+02:00

In my earlier post I briefly discussed the generic repository (DAO) pattern. In short, I argued how it can be enhanced with paging and entity relation initialization capabilities. This time I am going to take on the pattern design itself, identify its weak spots and introduce an alternative and possibly more elegant form.

The typical DAO consists of an interface and implementation pair like the following

interface Repository {
    + create
    + update
    + delete
    + findById
    + findAll
}

class RepositoryImpl implements Repository {
    // implementation ...
}

When we want to add additional operations we need to create a new interface and class pair that extend the generic ones. That though, quickly becomes a cumbersome way of reusing code because of the single inheritance model of Java.

If we take a look back to the JDBC API, we see a more modular approach where each operation is represented by a separate object, all using the same interface. In that regard as one moves from JDBC, to JPA, to DAO, gradually gives up flexibility in favor of staticness.

What follows is an introduction of a different interface that maintains all the modularity of JDBC, the abstraction of JPA and the strong typing of DAO. The solution is to break each DAO operation into a separate query object and transform the DAO itself into a query factory and configuration container. The tricky part then, is to avoid exposing the query implementation to the client. To do so we need to break again each query component into a specification part and an implementation part. Without any more talking bellow are the core interfaces:

interface Query<E, R> { }

interface Repository<E> {
    <R> R execute(Query<E, R> spec);
}

Notice the high abstraction level of this API. The Query interface represents the specification part of the query components. It has two generic parameters, E for the entity type and R for the result type. Of course we still need the actual implementation for each operation. Parenthesis; at first I had an additional interface for these parts that followed the command pattern (so the title) though I figured later that it wasn't really necessary as a public API.

To demonstrate the “findById” operation consider the following:

class FindById<E> implements Query<E, E> {
    Object Id;

    FindById(Object id) {
        this.id = id;
    }
}

We can call this operation for an entity, lets say “Person”, with id 2 like this:

FindById<Person> spec = new FindById<Person>(2);
Person p = repository.execute(spec);

Or simply abbreviated like this:

Person p = repository.execute(new FindById<Person>(2));

So far we have gained little against using the standard DAO form and created more artifacts, though here comes the good stuff. We can now configure custom repositories by mix and matching any operations we like. This can be easy especialy with a dependency injection container like Spring. In the last example I demonstrate such a potential configuration with a read-only and a read-write template:

<!-- This is a repository with read only operations -->

<bean id=”readOnly” class="impl.Repository">
    <property name="queryCommands">
        <map>
            <entry key="FindById" value="impl.FindByIdQuery" />
            <entry key="FindAll"  value="impl.FindAllQuery" />
        </map>
    </property>
</bean>



<!-- This is a repository with read and write operations -->

<bean id=”readWrite” class="impl.Repository">

    <property name="queryCommands">
        <map>
            <entry key="FindById" value="impl.FindByIdQuery" />
            <entry key="FindAll"  value="impl.FindAllQuery" />
            <entry key="Create"   value="impl.CreateQuery" />
            <entry key="Update"   value="impl.UpdateQuery" />
            <entry key="Delete"   value="impl.DeleteQuery" />
        </map>
    </property>

</bean>

Flexible Repository

2008-11-25T17:40:00.026+02:00

I have been using a repository class for data access following closely the generic DAO pattern. Due to my requirements though, the api evolved and became quite inflexible. This is my first post about my quest to design a more flexible generic repository.

The initial version of the repository interface looked like most of the examples available throughout the net:

public interface Repository<E, I> {
    E create(E entity);
    E update(E entity);
    void delete(I id);
    E findById(I id);
    List<E> findAll();
}

This worked for the most simple cases, though it is obvious that there is a serious issue with the methods that return multiple results, their size could easily turn too big. For this reason I altered them and applied a paging policy as follows:

DataPage<E> findAll(int pageStart, int pageCount, String pageOrder);

Where DataPage is a simple bean container like this:

public class DataPage<E> implements Serializable {
    private Collection<E> data;
    private int total;
    // getters & setters
}

That was better, yet still not very flexible for my needs.

Entities have two different kinds of properties, values and relations. The default fetch policy for relations is lazy. I wanted to have a uniform way to define relation properties that should be initialized. For that I added to all retrieval methods a String vararg as such:

    E findById(I id, String... initRelations);

    DataPage<E> findAll(int pageStart, int pageCount, String pageOrder, String... initRelations);

At this stage the interface supported all my requirements but one. I wanted the clients of this class to be able to extend its functionality, though without necessarily having to extend its implementation! Additionally after the above modifications, its interface had lost some its initial elegance and it was whispering re-factoring.

The final part of the modularization I will explain the next post.

How to install NFS in Ubuntu Linux

2008-05-21T22:16:00.008+03:00

To install the client packages:

sudo apt-get install nfs-common

To install the client and server packages:

sudo apt-get install nfs-kernel-server

Once the server is installed, we can setup the directories that will be shared with the file:

/etc/exports

To share, for example, the directory /mnt/shared to a typical local network with the default settings we need to put the following line:

/mnt/shared 192.168.1.1/255.255.255.0(sync,ro,root_squash,wdelay)

After we save the file we can activate the changes with the following commands:

exportfs -ua
exportfs -a

Now to enable the share from a client computer we execute the following:

mount -t nfs server_address:/mnt/shared /local/path

PS. The default options when we export a directory are: ro, sync, wdelay, root_squash, no_subtree_check and they are implicit. Thous in the following examples are equal:

/mnt/shared 192.168.1.1/255.255.255.0(rw)
/mnt/shared 192.168.1.1/255.255.255.0(rw,sync,wdelay,root_squash,no_subtree_check)

For more information see exports and exportfs man pages

How to install MySQL autonomously on Linux

2008-03-22T11:12:00.006+02:00

These are the necessary steps to install MySQL autonomously on Linux under the /opt directory.

First we need to fetch the program from the official MySQL web site. From the download area we choose the "MySQL Community Server", then the version we like and then the option "Linux (non RPM packages) downloads". In this case I picked the latest stable 5 version:

mysql-5.0.45-linux-i686-glibc23.tar.gz

From then we log as root to execute the installation scripts. The tasks we have to do are the following:

Create a specific user and group
Extract the zipped file to its destination
Create a basic configuration file
Initialize the database
Set up file permissions
Set up the service startup script

Create mysql user and group

groupadd mysql
useradd -m -g mysql mysql

Extract the zipped file to /opt

tar xzf mysql-5.0.45-linux-i686-glibc23.tar.gz -C /opt
ln -s /opt/mysql-5.0.45-linux-i686-glibc23 /opt/mysql

Create the configuration file
With a text editor we create a file my.cnf under /etc with the following basic configuration data:

[mysqld]
basedir=/opt/mysql
datadir=/opt/mysql/data
character-sets-dir=/opt/mysql/share/mysql/charsets/
character-set-server=utf8
user=mysql
port=3306
socket=/tmp/mysql.sock

[client]
default-character-set=utf8
port=3306
socket=/tmp/mysql.sock

Initialize the database

cd /opt/mysql
scripts/mysql_install_db --user=mysql

Set up file permissions

chown -R mysql:mysql /opt/mysql

Set up service startup

cp /opt/mysql/support-files/mysql.server /etc/init.d/mysql
chmod +x /etc/init.d/mysql

Finaly for Fedora Linux:

chkconfig --add mysql

and for Ubuntu / Debian Linux:

update-rc.d mysql defaults

FHS is flawed

2007-11-10T01:24:00.008+02:00

Recently I had a strong discussion with a couple of linux enthusiasts regarding the filesystem hierarchy and /usr in particular which motivated me to write a blog about it. For those who might not know, /usr is the place where Linux systems hold most of their applications' files and it is subdivided into the following directories:

`bin`			Most user commands
`include`			Header files included by C programs
`lib`			Libraries
`local`			Local hierarchy (empty after main installation)
`sbin`			Non-vital system binaries
`share`			Architecture-independent data

This certainly looks like a reasonable scheme. The important thing though is that files, are kept merged all together within each of the above directories and a couple of other places - like /etc for configuration and /var for data. This is an architecture that I claim to be flawed from certain aspects.

The most apparent flaw is the misuse of Unix's central component, the file system. As a naming system its primary job is to provide distinct hierarchical name spaces for software packages. Consequently it would seem logical for each distinct program to live in its own separate space but this is not the case with Linux.

Lets see an example. A listing of my /usr/bin reports 1850 files. Here are a few of them:

...
apt-cache
apt-config
apt-extracttemplates
apt-get
...
gnome-about
gnome-accessibility-keyboard-properties
gnome-audio-profiles-properties
gnome-background-properties
gnome-btdownload
gnome-calculator
gnome-cd
...
ssh
ssh-add
ssh-copy-id
ssh-keygen
ssh-keyscan
...

Do we see a pattern here? The name-space is embedded directly into the filename, an ugly side effect of the /usr architecture. This is just an inconvenience though, as the real problem is that we cannot tell which other files in other directories constitute each of the above programs.

For this reason Linux distributions have invented special programs in order to hold these information called package-managers. These programs provide convenient features like central access to massive software repositories and dependencies resolution. Their primary function however is to keep track of the several components (binaries, libraries, data) that are scattered throughout the entire system so when there is a need to remove or update a program the package managers know exactly which files should be handled and from where.

Another flaw of the /usr design is it's inflexibility. Many programs do not strictly comply with the above static structure if at all. For example a default Apache Tomcat installation from tar.gz is structured as such:

tomcat/bin
tomcat/conf
tomcat/logs
tomcat/lib
tomcat/shared
tomcat/temp
tomcat/webapps
tomcat/work

but we install it through the package manager, we end up with this:

/usr/share/tomcat/bin
/usr/share/tomcat/lib
/etc/tomcat
/var/log/tomcat/logs
/var/lib/tomcat/shared
/var/tmp/tomcat
/var/lib/tomcat/webapps
/var/run/tomcat

In the former case we are dealing with a a solid self-contained package while in the later with several fragmented pieces. Moreover the source code of the program possibly had to be altered in order for this reorganization to work, a process which is often poorly executed from people not affiliated with the organization or the developers that made the program in the first place.