Another nice cartoon from Oliver Widder: usually commenting out code does not lead to clean code, but sometimes we do it nevertheless. This explanation is nice: every line of code is a child of mine

You have heard of CEOs (chief executive officer), CTOs (chief technical officer), and CIOs (chief information officer). C-Level titles for jobs with high salaries. Dilbert has some more: CJO (chief janitorial officer) ..

.. CPO (chief people officer) and CACCO (chief artificial coffee creamer officer)

Have you ever wondered what the Linux equivalent of CTRL-ALT-DEL in Windows is? Many Linux fans say in Linux an application cannot bring down the whole system. Well, it can. It happens rarely, but it does happen. Here is what you can do for example in Ubuntu, which uses Gnome:

• With Ctrl-Alt-BackSpace you can kill the whole X-Server Window System (or your GUI session) and return to the login prompt.
• If an app blocks the whole system, you can press Ctrl-Alt-F1 (or F2 through F6) to get a console and kill the evil process with ps aux or ps -e | grep program_name and kill -9. Finally go back to your display manager with ctl+alt+f7
• In Gnome, you can add the System Monitor to the Panel. When you click on one of the monitors (for processor, memory, network or harddisk), a graphical list of processes opens, similar to the Task Manager in Windows, and you can stop processes through the context menu.
• In Gnome you can also press Alt+F2, type in xkill, press enter, and kill the non-responding application. KDE is still different..

Is this so much better than the famous Ctrl-Alt-Del in Windows? I am not sure.. Anyway, it looks like this is a very operating system specific feature. For Mac OS X, there is no ALT key, but you have an option key instead and two Command or Apple keys. Option-Command-Esc brings up a force-quit menu. You can also open the activity monitor (by opening Spotlight with the shortcut Command-spacebar and typing “act”).

see more Lolcats and funny pictures

Did you notice that Continuous Integration and Agile Development are similar? The principle of continuous integration means that members of a team integrate their work frequently, because merging is much easier to do frequently and small rather than rarely and large. Agile development means iterative development with many feedback rounds between customer and developer. The common thread is that frequent interaction reduces conflicts and prevents that things diverge too much from each other:

• frequent integration through merging avoids in Continuous Integration that different branches diverge too much from each other
• frequent feedback rounds and iterations in Agile Development avoid that expectation from the customer, specification from product manager and real product from developer diverge too much from each other

Powerful IDEs such as Eclipse or NetBeans are useful even for dynamic languages as Ruby, which don’t need to be compiled like Java or .NET applications. They offer all necessary functionalities, syntax highlighting, and debugging possibilities. Yet they also have drawbacks, sometimes they are quite slow: Eclipse seems to be very slow at large CSS files, while NetBeans constantly tries to scan all your projects. And sometimes their behavior is difficult to understand. For example, if you get the error message “Could not connect to webserver” in a NetBeans RubyOnRails project, then you might have a faulty plugin or gem. This is possible if you just have modified or edited it. Then you have to restart the server, and this does not work if you have introduced a fatal error. If the Rails application can not be started, then NetBeans does not display the correct error message. It simply says “Could not connect to webserver”. The reason can also be a missing or faulty gem which is required for your application, for example a broken rmagick gem after an OS update of Linux. In this case, examine the log in the output window (which can be opened in NetBeans with Ctrl-4) and install the required gem.

Sometimes things are not always what they seem..

Shakespeare’s sonnets have exactly 14 lines, his plays have usually around 2600 lines (Hamlet about 4000 lines). This is not that different from the few thousand lines of code a typical programmer writes for a unit, library or project, for example jQuery 1.2 and 1.3 have around 4000 LoC (jQuery 1.2.6: 3549 LoC, jQuery 1.3.2: 4376 LoC). It is well-known that progress and productivity cannot be measure in lines of code. Yet the order of magnitude is often quite similar in completely different projects and environments, because there is a limit what people can handle and produce.

The order of magnitude for the typical lines of code is as follows. A single programmer working a few days will usually produce some functions, methods and classes more or less rapidly, depending on his experience. If he is working a few months he will produce typically a few thousands lines of code. This is an amount a single person can still understand well, and it can still be customized and changed easily:

• function/method: 10 = 10^1 LoC/Method
• class: 100 = 10^2 LoC/Class
• library or small project: 1000 = 10^3 LoC/Project

A few programmers together working a few months will produce about 10^4 lines of code. This is an order of magnitude where it is becoming difficult for a single developer to understand and comprehend the complete code base if it is not well structured. According to DHH, Rails on Rails 2.3 has currently about 35.000 LoC (without tests and comments). A large framework requires about 10^5 lines of code. A complete operating system belongs to the largest software projects, it requires about 10^6 – 10^7 lines of code, Microsoft Windows 2000, Windows XP and early Debian Versions for example are said to have around 50.000.000 lines of code or ~5GB of data:

• a small framework or large application: 10.000 = 10^4 LoC/Framework
• ide/framework: 100.000 = 10^5 LoC/Framework
• operating system: 10.000.000 = 10^7 LoC/OS

For comparison only, a human has around 30,000 genes (~3.1B base pairs ~ 1.5GB). Modern versions of Debian Linux have up to 280.000.000 lines of code, see here. This is a tremendous amount of code which a single programmer can hardly handle anymore.

As a computer programmer or software developer, you long each day for world domination. To be precise, you stagger constantly between world domination (in German “Weltherrschaft”) and total powerlessness, between absolute might and complete plight, between omnipotence and complete impotence. One day you feel like a mighty emperor, and the next day you feel like a powerless subject. Here’s why:

In the world of your own software, you are the lawgiver with absolute power and undisputed authority. This means world domination: everything follows your command without the slightest kind of opposition or resistance. The programmer determines in detail what every object, every class and every function should do, step by step, in every possible situation and in every possible context.

“The computer programmer is a creator of universes for which he alone is the lawgiver…No playwright, no stage director, no emperor, however powerful, has ever exercised such absolute authority to arrange a stage or a field of battle and to command such unswervingly dutiful actors or troops.”
(Joseph Weizenbaum)

The programmer and developer is the ultimate commander. Ideally he can create a whole application with only a few lines of code, he can create worlds with his fingertips. That’s the fun part. Yet despite all this power, and no matter how smart you are, as a programmer you will typically trying to understand what is going on most of the time. The problem is you usually use a lot of code from others – plugins, modules, units, libraries, frameworks – which you do not and can not understand completely. Even your own legacy code from the past is sometimes difficult to understand. Debugging foreign code is like walking around in a foreign city without a map. You don’t know how everything is connected, where the center is, or where everything leads to.

And there are always bugs around the corner waiting to be solved. Bugs belong to software like explosions to rockets. Rockets are based on controlled gas flow which results in explosions. Software is based on controlled program flow which results in features and bugs: there is saying that “the only difference between a bug and a feature is the documentation.” If debugging is the process of removing software bugs, then programming must be the process of putting them in.

Because there are always code parts which he doesn’t understand or bugs which he is trying to solve, a programmer gets often completely stuck, and falls into total powerlessness, until he is able to find out what happened. For a programmer, it is extremely important to find out what happened: either by examining existing or newly created log files, or by debugging (that is by stepping through the code bit by bit). Once a bug has been identified and located by logging and debugging the code, it is often easy to remove it, and the programmer is ready to dominate the world again.

This is why programmers stagger constantly between world domination and total powerlessness. Programming is 20% world domination and 80% frustration. Unfortunately, the frustrating times prevail, but the world domination times compensate for everything.

(The Flickr photo is from the user Toni Villen)

I am on holiday for the next weeks

We know that a picture is worth a thousand words. A few charts can indeed improve any application and presentation..

..sometimes it works too well:

Often one must traverse a list or array of items to find and return the first instance with a certain property, attribute or id. For pattern matching in strings or texts, one would use regular expressions. For object matching in lists or arrays, usually one would write a function like this:

result = nil
instances.each do |instance|
  if instance.id == _id
    result = instance
    break
  end
end

With the detect method of the Enumerable module in Ruby this is quite easy. It returns the first object for which the passed block is true, for example the first element which is divisible by 5 and 7:

instances.detect{|instance| instance.id == _id}

(1..100).detect {|i| i % 5 == 0 and i % 7 == 0 }
=> 35

From the Daily WTF:: an error in an error message:

this is also great: the word of the day

As a dynamic script language, Ruby provides a few different options to evaluate a string or a block of code: eval, class_eval, module_eval, and instance_eval. What is the difference between them? This article describes it well. The main different is the context: instance_eval evaluates in the context of a certain instance, module_eval (and class_eval) in the context of a class, and eval in the current context or the context of the given binding.

instance_eval

Object.instance_eval evaluates a string (or the given block) within the context of a certain class instance and allows thus the direct access to class properties without attr or attr_accessor. It allows you to define new methods for a instance

class Klass
  def initialize
    @secret = 99
  end
end
k = Klass.new
k.instance_eval("@secret")    # => "99"
k.instance_eval("@secret=42") # => "42"

k.instance_eval("def hi() \"Hello there\" end")
k.hi()  # => "Hello there"

eval

Kernel.eval evaluates a string in the current context or the context of the given binding. It is the method used by IRB to process your input. It allows you to define new variables and methods for the current context.

def secret(number)
  return binding
end
number = "42"
eval "number"                #=> "42"
eval "number", secret("99")  #=> "99"

eval "def hi() \"Hello there\" end"
hi()  # => "Hello there"

module_eval

As the name says, Module.module_eval evaluates the string or block in the context of a module or class (Synonym: class_eval). module_eval allows you to define new instance method for a class.

String.module_eval do
  def secret
    "42"
  end
end

"string".secret    #=> "42"

Dilbert has got the point again, here is a nice cartoon about MBAs:

and a follow-up here