What’s so fascinating about these two philosophies and aesthetics is how they contrast so sharply, and yet share so many conceptual similarities. As Koren puts it in his book:

• Both apply to all manner of manmade objects, spaces and designs.
• Both are strong reactions against the dominant, established sensibilities of their time. Modernism was a radical depature from 19th-century classicism and eclecticsism. Wabi-sabi was a radical depature from the Chinese perfection and gorgeousness of the 16th-century and earlier.
• Both eschew any decoration that is not integral to structure.
• Both are abstract, nonrepresentational ideasl of beauty.
• Both have readily identifiable surface characteristics. Modernism is seamless, polished, and smooth. Wabi-sabi is earthy, impefect, and variegated.

Wabi-sabi being summed up as the beauty of things imperfect, impermanent, and incomplete. Is is a beauty of things modest and humble.

I guess this is mainly a way of promoting ones book, but it’s been a while since I actually read anything new on Javascript, since Douglas Crockford mostly has this business down in terms of the core language itself these days. But a book about testing sounds interesting to me, because while I have always loved the core language, JS has often had rather mediocre tools in my eyes, and will be interesting to see what the book offers up in this area.

On an unrelated note, I can add that while I rarely update this blog, I do run a rather useless twitter account which I attempt to spam with inane stuff as much as possible, as is the custom!

Anyway, lusty-explorer adds quick ways to browse either the loaded buffers, or browse the filesystem, but doing both in a way which blows away the built-in directory browser in Vim. But the way I like to browse files is basicly with a “recently used” file list, which should include currently open files. So with some changes to the lusty-explorer script, it now has a great “recently used” explorer, which I find totally eliminates any need to check currently loaded buffers. Want to open a file you know you’ve opened recently? Just hit <leader>lu, and the last many files you opened are there, easy to get to. If the file is alredy open, Vim just switches to that buffer, just like if you had entered :e file.

Get lusty-explorer-mod.vim.

Remote Desktop, Consolas and ClearType, oh my

Something else which I’ve found a need for, is a capability to detect when Vim is used in a remote desktop session. Since I spend maybe half of all my time working in a RD, where ClearType is usually disabled, that means that my preferred font, Consolas looks like shit. While not the same as having ClearType disabled, I found that the easiest way out was to check if the current session was via Remote Desktop (look for the SM_REMOTESESSION.) Thankfully that’s pretty easy to check. Here’s a minuscule C program which does this.

#include <windows.h>
#pragma comment(lib, "user32.lib")

int main(void) {
    if (GetSystemMetrics(SM_REMOTESESSION)) {
        printf("1");
    } else {
        printf("0");
    }
    return 0;
}

The precompiled file here is compiled for 32bit, on WinXP, but tested on 64bit 2008 Server as well, where it should work just fine, through the miracle of WOW. You can use this small executable, by dropping it in the path of computers where you use Vim, and where you might also log in via Remote Desktop, and then you can tweak your _vimrc like this:

if has("gui_running") " gvim is running
    if has('win32')
        set guifont=Consolas:h11:cANSI
        if system("remotesession") == "1"
            set guifont=Lucida_Console:h10:cANSI
        endif
    endif
endif

Lets you get the best of both worlds, Consolas, when ClearType is (probably) present, and Lucida when not (Lucida Console is still fairly decent.)

Recently, I tried to use jQuery, as a way of dynamically loading all the scripts that a certain page requires. Instead of utilizing script tags in the header section, using a simple $.getScript("script.js"); loads the same code, what’s more, this code is loaded asynchronously, which helps improve loading performance. The only problem is that loading scripts this way, makes them unavailable for debugging.

Debugging dynamically included script files presents some special challenges on it’s own. The primary being that that the web is basicly not a structured enviroment, like a folder on disk, and references to files and/or code is can be very intermittent.

Some methods for loading remote code

Here’s just some of the many ways that code may be included dynamically in a page (these are just rough outlines, buyer beware.) Be especially wary that this code is specifically for loading scripts, if you want to load JSON, you’ll need a different approach, just spilling your guts in the global scope is quite messy.

1. Using XMLHttpRequest to load the script, and then insert via DOM methods into the page itself.

   var req = new XMLHttpRequest();
   req.open('GET', 'delayed.js', true)
   req.onreadystatechange = function(e) {
       var head= document.getElementsByTagName('body')[0];
       var delayed = document.createElement('script');
       var txt = document.createTextNode(req.responseText);
       delayed.appendChild(txt);
       head.appendChild(delayed);
   }
   req.send();
   

2. Using XMLHttpRequest to load the script, and then use eval to execute the code in the global scope.

   var req = new XMLHttpRequest();
   req.open('GET', 'delayed.js', true)
   req.onreadystatechange = function(e) {
       eval(req.responseText);
   }
   req.send();
   

3. Dynamically create a script tag with DOM methods, and then point it’s src attribute to the script you wish download.

   var head= document.getElementsByTagName('head')[0];
   var delayed = document.createElement('script');
   delayed.onreadystatechange = function() {
       if (delayed.readyState == "loaded" || 
           delayed.readyState == "complete") delay();
   }
   delayed.src = "delayed.js";
   head.appendChild(delayed);
   

   This code also details how you can get a callback for when the actual script has loaded, so you’re not “missing” out on the callback functionality of XMLHttpRequest.

jQuery basicly executes the first approach. The little twist is that just after the script has been added to the browser, it removes the tag again, so it’s not “littering” the document DOM with these script tags the author himself didn’t insert. This can be seen in the jQuery script at around line 646, where you find the globalEval function (assuming the development version, not the minified versions.)

The problem with anonymous code

This is all dandy, the problem simply is that no debuggers expose the anonymous code which enters the global scope in this fashion.

Firebug showing a webpage with both a static and a dynamically loaded script (the script was loaded with jQuery, but with a modified jQuery so that it leaves the node in the DOM). Everything looks fine.

Firebug’s script tab shows a different view, namely the one where the dynamically loaded script block is gone, and thus not available for debugging.

If you try to load the following script, with this piece of jQuery, $.getScript("delay.js", function() { delay(); });, will lead the debugger to exclaim that the method name is “anonymous”!

function delay() {
    alert("hello from delayed.js");
    console.trace();
}

Loading code for proper debugging

As you can see, the way that jQuery (and many other libs) chooses to load their scripts is a rather high-tech one, and the solution is as simple as not using XMLHttpRequest. By utilizing the third method of remotely loading scripts, allows you to morely accurately debug the scripts.

Take the following page and two script files for instance:

<html>
<head>
<script type="text/javascript">
function load(scriptSrc, callback) { 
    var head= document.getElementsByTagName('head')[0];
    var script = document.createElement('script');
    script.onreadystatechange = function() {
        if (script.readyState == "loaded" || 
            script.readyState == "complete") callback();
    }
    script.src = scriptSrc;
    head.appendChild(script);    
}
</script>
</head>
<body>
<p><a href="javascript:load('load1.js',function() { load1(); });">load 1</a></p>
<p><a href="javascript:load('load2.js',function() { load2(); });">load 1</a></p>
</body>
</html>

function load1() {
    alert("hello from load1");
}

function load2() {
    alert("hello from load2");
}

If we look at IE8′s Developer Tools JS debugger, you’ll notice that on page load, the scripts drop-down does not contain neither load1.js or load2.js.

IE8′s Developer Tools on initial loading of a simple HTML page.

If we try to click the links however, the scripts we load will appear in the dropdown, and allow easy debugging.

IE8′s Developer Tools after having clicked the load link, the loaded script is now available for easy debugging (this works just as well in Firebug btw.)

Debuggers

Debuggers are still lacking behind in this area, compared to debuggers operating in more stable enviroments. There’s no denying that the web presents unique challenges, but the fact remains that the code is available for execution, but is not exposed for debugging. So while JS debuggers has moved forward since the days of Venkman, I think there’s still ways to improve (and this need will become more pronounced as the dynamic nature of the web increases with time).

The term “W32″ is used to describe the API used by current Microsoft Windows versions. We don’t use the Microsft terminology here; in hacker terminology, calling something a “win” is a form of praise. Keep in mind that Windows ist just a temporary workaround until you can switch to a complete Free Software system. Be the source always with you.

The Windows API is normally referred to as “win32″ (the 32 is a reference to the fact that it’s a 32 bit machine API). So by refusing to refer to the term “win32″, and instead use “W32″, it merely comes across as a totally juveline display of non-professionalism. Being termed a “hacker” is an honorary term in the programmer community, and as with all such things, you don’t get to name yourself a hacker. So it’s not only slightly buffoonish with the allusion to the hacker term “win”, it’s also quite campy with it’s Star Wars reference.

I’m all for the Unix philosophy and open source. In fact, I think it’s healthy for the IT world, that some people think in terms of more then just money. But when dogmatic advocacy gives trumps real world pragmatism, I’m off the train.

How do you handle non-english terms in your code?

I imagine most programmers write their code in english. This simply makes the most sense, I’m sure people will agree with this. The vast majority of pre-existing code (libraries, APIs) is in english. The literature and enviroments that programmers need to work in or with are english. And sometimes even technical issues, such as tool chain inabilities to handle some more complex character sets. While the issue is fairly banal, it does relate to the core issues in programming, semiotics and the encoding of meaning in the written word.

Programming is solving problems in some domain, be it mathematics, the local post office or a ticket seating systems for a stadium, and as such, you deal in the terms found in that domain. But when you’re not dealing with an english domain term, how do you handle that? I’m sure almost every non-english CS student has come across this issue, as universities tend to be a place where the native language is valued highly (and rightly so), and thus even very technical terms have found local translations.

The problems of encoding and translations are not new issues. The image depicts the top of the Rosetta Stone, showing the then lost egyption heiroglyphs encoding.

Indblikskode versus Access code

To keep it from being completely abstract, let’s take on an example. At work, we have a massive EDM system. As part of the security of this system, there’s a term called “indblikskode”. This denotes a code which a user has in the system. The code allows the user to view (and otherwise interact) with documents in the system. So, do we translate this danish term, or do we use it as is?

Indblikskode is an exact term with a specific meaning when coupled with our EDM system, but if I translate it into for example “access code”, which may well mean the same thing, it has lost all the embedded meaning when coupled with our EDM system. If we forego a translation, we risc ending up with pidgin english, such as getIndblikskode();. Having myself, and anyone who may have to handle the code, plays translator isn’t exactly very productive either. And herein lies the issue.

How to properly balance the loss of information as you move away from the terms of the problem domain, versus the problems of mixing languages.

As always the answer is probably “it depends”. Who will look at the code after you’re done with it? How well can translations actually be made? Can only some terms be translated? The issue is that this problem is most oftenly handled by programmers, who sit with their editors, and are naming variables. It’s unrealistic to expect to commitee such work, and most programmers must simply work from a gut feeling.

So, at work I find that I need a function which takes a variable number of GUIDs, and presents me with a compounded status integer, pulling status indicators for each GUID, and producing a single status. Should be simple right?

First off, I need this to be a function, so I can use it in SELECT constructs for a view. Why SQL has these random limitations on what can appear where, I’ll never know, but there it is. Then, the wild notion that I could pass in a variable number of GUIDs is killed fairly off quickly as SQL doesn’t support variadic functions.

So ok, I need to pass in the GUIDs in a single data structure. Of course, I know right off the bat, that I can’t pass tables (<sarcasm>why would anyone wanna do that anyway?</sarcasm>), so we’ll just pack a string with the GUIDs I need. I’ll live with myFunction("guid1,guid2,guid3"). So taking a look over the extremely rich string function library in SQL, I notice there’s no split function. So I need to write that first.

Writing an SQL string split function

So let’s just lay it out there. In all it’s glory.

CREATE FUNCTION dbo.Split (@String VARCHAR(500), @Delimeter CHAR(1))
RETURNS @Strings TABLE (String VARCHAR(500))
AS
BEGIN
    DECLARE @Position INT,
            @Next INT,
            @DelimeterWidth INT,
            @Substring VARCHAR(500)

    SET @Position = 1
    SET @Next = 1 -- set to 1, just to get past initial while cond
    SET @DelimeterWidth = LEN(@Delimeter)

    WHILE @Next > 0
    BEGIN
        SET @Next = CHARINDEX(@Delimeter, @String, @Position)
        IF (@Next-@Position) >= 1
        BEGIN
            SET @Substring = SUBSTRING(@String, 
                                       @Position+1, 
                                       @Next - @Position - @DelimeterWidth)
            INSERT INTO @Strings(String) VALUES(@Substring)
        END
        SET @Position = @Next
    END

    RETURN 
END

You’ll notice this returns a table. This table is btw also the only one you have to work with, no creating temporary tables! For some reason, you’re not allowed to create tables inside functions. So once you’re past the 1-indexed strings, you’re almost there . I know that 0 versus 1 indexing is a religious war onto itself, but given Cantor’s ordinals start at 0, it does not seem entirely silly either. For a language so focused on sets, it seems a strange choice.

They phoned it in

SQL sometimes really feels like they sat down, thought about SELECT, sub-selects, joins, and the related set algebra, and decided “nice work” and phoned the rest in. Even INSERT makes no sense, why do we need to seperate the column names from the values?

INSERT INTO tbl(col1, col2, col3) VALUES(val1, val2, val3)

UPDATE does it right.

UPDATE tbl SET col1=val1, col2=val2, col3=val3

Know what’s being sold as a exciting new feature in SQL 2008? Declaring and assigning values in one line!. This is how low the bar is set. SQL is obviously not going anywhere, but I can’t for the life fathom why it has to be so abysmal at almost everything, except the little core which it does so well.

Let me know if there’s any bumps on the site!

List<Guid> gs;
string s;

foreach (Guid g in gs) {
    s += "Id='" + g.ToString() + "' OR ";
}

if (result.Length > 0) {
    s = s.Substring(0, s.Length-3);
}

That’s some good ole fashioned string fucking, and since I’ve come over from HTML/JavaScript/(Classic) ASP/PHP, that’s bussiness as usual by all standards. But I’ve never liked several aspects of it.

• Since you’re appending to the string always, you need to take the last bit off, or the string turns malformed. That’s what the if construct does. It can sometimes be hard to connect a large foreach/for block with a succedding if block.
• Contains magic numbers, in this case, 3. Can be avoided of course, if the bit that you’re appending is saved as a variable, and then you take the length of it. But that’s just more work.

Another approach, using generics and anonymous methods is the following

s = string.Join(" OR ", 
        gs.ConvertAll(
            new Converter<Guid, string>(
                delegate(Guid g) { 
                    return string.Format("Id='{0}'", g.ToString()); 
                }
            )
        ).ToArray()
    );

or, if you’re running C# 3.0 (my work is still using 2.0), you can do away with most of the syntax for the delegate construction.

s = string.Join(" OR ",
        gs.ConvertAll(
            new Converter<Guid, string>(
                g => string.Format("Id='{0}'", g.ToString())
            )
        ).ToArray()
    );

Which is a radical departure from the for loops of yore. Probably debatable if it’s an improvement in actual performance (string.Format is faster then old string concatenation, but you could use string.Format with the first approach too of course). It’s a much more functional approach, with no side-effects. But in terms of what is pleasing to the eye, I have no doubts, even if it’s spanning more lines, it just feels more right. You never end up over doing it, so there’s never any string to remove. The act of creating the strings you need, and then joining them is also seperated, which feels more right.

The downside is that it does become harder to debug. If you have a line like for instance

bool b = SomeMethod(GetSomeValue(param1, param2), param3);

Using either a normal debugger it’s not easy to break on the method call to GetSomeValue. The same would be the case with the list comprehension at work here. With no assigned value, it’s a little harder for the debugging. But given the simplicity, it usually proves to be a non-issue for myself.

We spent years agonizing over the lack of 8-bit alpha channel in PNG in IE, and when we filly get it natively/nicely supported in IE they go and botch is so horribly.

Most of us have heard about gamma. But unless you do something in the graphics/print field, it mostly remains a button on our screen, where we tweak the luminocity of the screen. But of course, when an artist makes a snazzy PNG picture, making sure that it appears at the same display intensity as it did on his screen is understandably an laudarble goal. So PNG embeds gamma information, saying that this and that color, should be show at this and that intensity. The problem occurs when the BOG STANDARD (for 15 years and counting) HTML and CSS colors are NOT processed through the same system and thus don’t get the same gamma correction applied. The problem is easy to spot (need to be viewed in IE). The PNG files, once stripped, appears correctly.

I won’t really bother explaining this problem more, since it goes beyond stupid, I’ll just link further reading materials if you don’t know why you may wish to strip your PNG files for gamma information. Henri Sivonen has the best treatment on the topic.