Blog::Log

I recently read Coders at Work (published by Apress), here is a quick book review…

One way to describe this book, in a somewhat generalized way, is to say “Old people talking about when they were programmers”. The book is a collection of transcript style interviews with some of the most protruding people in the history of computer programming. 15 interviews in all, from Jamie Zawinski of Netscape fame (the young one of the lot, thereby the “old people” tongue-in-cheek reference) to Donald Knuth.

Each interview is prefaced with a short introduction of the interviewee, followed by a discussion around a number of topics; how did you learn to program, how do you prefer to read code, hardest bug you tracked down, do you think of yourself as a scientist, engineer, artist or craftsman, what do you think of formal proofs, have you used literate programming, how do you interview candidates for employment, and more.

The author, Peter Seibel, is himself an experienced programmer resulting in insightful questions that only someone with great knowledge about programming may ask, making the interviews more free and targeted towards the interest of the particular person. It also makes the discussion feel more genuine and honest, rather than a set of questions and answers following a strict agenda.

The focus of the interviews are not technology, but the person being interviewed and how they look back on their career. The technical discussions typically centers on systems like PDP and programming in LISP. Although most issues are still relevant today in some way or another, the context is usually not on today’s technology (you do not program using punch cards, do you?).

That means that this book is not for someone looking at quick technical tips to apply in their current programming language of choice. But for those genuinely interested in the craft of software development this book is inspiring and gives insight into the people who were significant in some way bringing the industry into what it is today.

The book really does not analyze the answers in the interviews to a greater extent, leaving that to the reader. But to mention a few reoccurring themes there seems to be a consensus that programming is harder today (mostly because of parallelization) and C++ (and especially pointers) is crap.

Notable famous people missing from the list are Linus Torvalds (Linux) and John Carmack (Doom/Quake). Both were contacted by author Peter Seibel but he never got an answer. Additionally, most of the interviewees look back at the time when they were programming as their main profession, this is not a list of the superstar programmers of today (which would make a great follow up book).

All in all, if you are interested in the people, how they are and what their thoughts and experiences are like, then this book is for you – you’ll likely find it both inspiring as well as entertaining as I did. If you want source code listings, look elsewhere.

Just copying a VirtualBox .vdi file and the opening it results in the error:

Cannot register the hard disk ‘myhd.vdi’ with UUID {ABCD} because a hard disk ‘myhd2.vdi’ with UUID {ABCD} already exists in the media registry (‘path/VirtualBox.xml’).

The solution is to generate a new UUID for the copy. This is done using:

VBoxManage internalcommands setvdiuuid myhd2.vdi

Getting the value of a the currently selected radio button may be done in a couple of ways. This is one approach using YUI 3.

Here is the HTML:

<input type="radio" name="myoptions" value="one"> First
<input type="radio" name="myoptions" value="two"> Second
<input type="radio" name="myoptions" value="three"> Third

Get the currently selected value using only one line of code:

var value = Y.one('[name=myoptions]:checked').get('value');

Unfortunately, this does not work in Internet Explorer, so another (not as tight) approach is:

function getRadioSelectedValue(selector) {
    var tmpValue= false;
    Y.all(selector).each(function(node) {
        if (node.get('checked') tmpValue = node.get('value');
    });
    return tmpValue;
}
var value = getRadioSelectedValue('.myRadioGroupClass'); // this assumes you've set appropriate class to radio elements

YUI 3 uses modules to group functionality and to only load what is used. This post describes how to create custom modules.

The typical way modules are used is within the use() statement:

YUI().use('node', 'event', function(Y) {
    // your stuff here
});

In the above example the modules node and event are loaded. Let’s see how custom modules may be included in the same way.

To define a new module the add() statement is used (note that it is a class and not instance method of the YUI object):

YUI.add('my_module', function(Y) {
    Y.myFunction = function() {
        var privateFunc = function() {
            // ...
        };

        return {
            publicFunc: function() {
                // ...
            }
        }
    }();
}, '0.0.1', { requires: ['node'] });

A common way to share functionality among different YUI instances is to use the YUI namespace when assigning the function. If you do not recognize the structure of the above function definition you may find out more by reading about the module pattern.

If the file containing the custom module code is loaded, the custom module may be used in any use() statements as normal YUI modules, i.e. use(‘my_module’, …).

To leverage the power of the YUI loader to dynamically load the custom module a configuration object may be created.

YUI({
    modules: {
       'my_module': {
           fullpath: "http://mydomain.com/js/my_module.js",
           requires: ['node']
       }
    }
}).use('node', 'my_module, function(Y) {
    // access functionality of custom module
    Y.myFunction.publicFunc();
});

One thing to note is that YUI currently only makes one request to fetch dependencies. That is why the module’s requires array must be specified in the configuration object as well, in addition to what is in the last parameter of the add() statement.

Using plugins in YUI 3 is a way to add functionality to existing objects in YUI (very much like you would use prototype to augment a function to a normal JavaScript object). Objects in YUI all derive from Y.Base.

Note that this post is about YUI 3 and not YUI 2.

However, the current YUI 3 documentation does really only get into how to add a plugin to a current instance. What about adding functionality to the class level so all instances of the same type of objects automatically get it?

First an example of how a simple plugin may look like:

NodePlugin = function(config) {
    this._node = config.host;
}

NodePlugin.NS = 'vis';
NodePlugin.NAME = 'NodeVisibiltyPlugin';

NodePlugin.prototype = {
    show: function() {
        this._node.setStyle('display', 'block');
        return this_node;
    },

    hide: function() {
        this._node.setStyle('display', 'none');
        return this_node;
    }
};

What this plugin does it to add hide() and show() functions to the vis namespace (as specified in the code) of Y.Node.

This plugin would typically be used like this:

var node = Y.one('#myElement');
node.plug(NodePlugin); // add plugin functionality
node.vis.hide();

If you would like to use the plugin functionality for all node objects it would be somewhat tedious to invoke plug() for each and every instance. The way to get around this, which is not really documented except in the API reference, is to use the static method Y.Plugin.Host.plug.

Y.Plugin.Host.plug(Y.Node, NodePlugin); // plug once ...

var node = Y.one('#myElement');
node.vis.hide(); // ... use anywhere

Now any new instances of Y.node have access to the plugin methods through the specified namespace. I also discovered that in order for this to work the static NAME property must be defined in the plugin object.