Planet Larry

As it is clear from the results, Opera 9.5 caches web content most effectively, performing 3-times less disk operations that Internet Explorer 7. FireFox 3 coming on the second place with a minor -12.87% disadvantage. Safari 3.1.2 is on the third place with 6,991 accumulated disk operations. Internet Explorer 7 is coming on the last place with a huge -66.63% disadvantage relative to the Opera web browser.

I filed a complaint against Westinghouse to the BBB, but two weeks later they haven't responded to it yet. Can't say I'm surprised. The good thing is that if they don't respond to the BBB, they get a big fat stinking black mark on their BBB profile. Might not do that much good, but it hopefully will let others know to avoid them.

I've gotten some posts from some people in the same situation of Westinghouse blowing them off and not sending them replacement items when their crappy merchandise breaks. Some people want to file a class-action lawsuit. I don't know if I'd go that far. I may take them to small claims court though. Before that, I'm going to write a letter to their corporate office, pointing out the existence of my website.

In the meantime, conclusions:

• Westinghouse doesn't give half a crap about its customers.
• Never ship anything expensive via UPS. They're happy to leave $500 merchandise sitting on your front porch (assuming it even made it to my front porch and the UPS guy didn't just keep it, how would I know? I never saw it).
• Beware buying things online. When they break, your options for getting them fixed or covered by warranty are limited, impractical, and prone to months of aggravation. Is it worth the time you save buying things online, when you have to spend six months going through the kind of bullcrap I went through over this monitor?

This is post is just a friendly reminder to everyone reading this, don't buy anything from Westinghouse, and tell everyone you know the same thing. I wonder if Westinghouse cares about all of the people whose business they flushed down the toilet by ripping me off?

(Read the whole crappy story of Westinghouse's dishonesty and horrible customer service: The beginning, Update 1, Update 2, Update 3, Update 4, Update 5, Update 6.)

I have had to use the TCL programming language recently, I don't know it well yet, and I have found the quickest way at the moment is to prototype in Python and then edit it into TCL code. This way I know the logic is sound, and therefore logic errors are not mixed in with syntax errors.

in the following example, I had a sequential list of numbers in TCL (which were unique ids of XML elements), and for a given number I had to find the nearest numbers on either side.

"""Nearest Neighbours in a list of numbers."""

def nearestneighbours(numlist, number):
    """For a given number, find the nearest lower and higher numbers in
    a given (ordered) list of numbers."""
    left = None
    right = float('inf')
    for i in numlist:
        if i < number and i > left:
            left = i
        if i > number and i < right:
            right = i

    return (left, right)

def main():
    """Demo when called directly."""
    mylist = [58163, 62140, 66139, 70280, 74371,
              78525, 82426, 86584, 90650, 94749]

    number = 67000
    lower, higher = nearestneighbours(mylist, number)
    print "Lower:", lower
    print "Higher:", higher

if __name__ == "__main__":
    main()

We have the function working as we want to, so now we can try to rewrite the code into TCL:

# Nearest Neighbours in a list of numbers.

proc nearestneighbours {numlist number} {
    # For a given number, find the nearest lower and higher numbers in
    # a given (ordered) list of numbers.
    set left 0
    set right 1000000000

    foreach i $numlist {
        if {[expr $i < $number]} {if {[expr $i > $left]} {set left $i}} elseif {
        [expr $i > $number]} {if {[expr $i < $right]} {set right $i}}
    } ;# end foreach

    set nearest [list $left $right]
    return $nearest
    } ;# end proc findnearest

proc main {} {
    # Demo when called directly.
    set mylist [list "58163" "62140" "66139" "70280" "74371" "78525" "82426" "86584"
    "90650" "94749"]
    set number 67000
    set highlow [nearestneighbours $mylist $number]

    puts "Lower: [lindex $highlow 0]"
    puts "Higher: [lindex $highlow 1]"
    } ;# end proc main

main

This works great.

However, I wrote the above Python code in a verbose way because I was sure I could replicate it in TCL, in a Python program, I can just use the Python list's sort method to find the neighbours.

def nearestneighbours(numlist, number):
    """For a given number, find the nearest lower and higher numbers in
    a given (ordered) list of numbers."""

    numlist.append(number)
    numlist.sort()
    return(numlist[numlist.index(number)-1],
           numlist[numlist.index(number)+1])

This works exactly the same as the much more long winded version at the start of this post. How does one do this in TCL? Well rewriting the Python gives us:

proc nearestneighbours {numlist number} {
    # For a given number, find the nearest higher and lower numbers in
    # a given (ordered) list of numbers.

    lappend numlist $number
    set numlist [lsort -integer $numlist]
    return [list [lindex $numlist [expr [lsearch $numlist $number] -1]]
                    [lindex $numlist [expr [lsearch $numlist $number] +1]]]

   } ;# end proc findnearest

This seems to work fine too, which is the preferred TCL way, I'm not sure.

#! /bin/sh
sync
echo 1 > /proc/sys/vm/drop_caches
sync
hibernate

"There are three kinds of lies: lies, damned lies, and statistics." (Benjamin Disraeli, link)

I hate having to reinstall Windows. I try to avoid it like death, but sometimes it's just inevitable. Asus sent a new motherboard, and as I've written before, new motherboards usually mean new chipsets, which mean new drivers, which mean Blue Screens of Death for Windows.

Thankfully, there were no blue screens of death. However, one of my hard drives stopped working shortly after this, but I think it was already dying. Regardless, my installation of Vista had become overly bloated, so I reinstalled anyways. Things seem a little more responsive, and I don't have a shitload of unneeded baggage trying to start when Windows does.

I eventually got the broken drive working again. Now I just need to get my other broken drive working so I can retrieve my pictures.

Eventually, I will switch over to pure Linux. I'm just waiting on the Linux port of Unreal Tournament 3.

On the Agenda...

(A) Re-do my audio cables that run from computers to my surround sound receiver. I didn't insulate them properly, so there's constant buzzing in the background. It's faint, but noticeable. Ideally, I'd like to replace the receiver and run an HDMI cable to it for digital audio. For now, however, I need to purchase new jacks.

(B) Finalize my Linux installation on my MacBook. I still need to get the touchpad, 3D acceleration, and wireless working properly. I can't wait to be able to play Unreal Tournament 2004 on it.

(C) On top of all that, I need to finish a ton of reviews. I'm still looking for more PC cases for review as well.

(D) Did I mention Pittco is quickly approaching? August 16th-17th doesn't seem all that far away. And yet there's so much to do!

Somehow AOL doesn’t brighten up my day. In fact, making me angry would describe it way better. As I am using Linux, I am trying to avoid proprietary software - that’s why you won’t find me that often using Skype. The Instant messenger of my choice would be Jabber, but as my contacts don’t use it, I have to use ICQ. My Client here is Kopete.

AOL now did a protocol bump for eliminating old clients, for pushing the ICQ6 protocol, regarding the error message and the Bugreport here.

However, this is quite nasty and I guess you don’t want to read rantings, you might want to see a solution - here it is. Add the following lines to your ~/.kde/share/config/kopeterc and should be able to connect again:

[ICQVersion]
Build=0×17AB
ClientId=0×010A
ClientString=ICQ Client
Country=us
Lang=en
Major=0×0006
Minor=0×0000
Other=0×00007535
Point=0×0000

The intuitive answer would be: no. Complexity is the huge cross we have to bear, the great weight that squashes our systems and makes them unmaintainable. We fight complexity tooth and nail, and hidden complexity is the worst kind, because it breaks things for reasons we don’t understand. So the least you can achieve with a system is grok the full complexity of it, even if it’s too much of a mess to do anything with.

On the other hand… if you take a step back and think about what programming really *is* then you might have to rethink that conclusion. It is, plainly, finding ways to solve problems of data processing in one way or another. And to be a coder that’s really all you need to know. It does mean that you risk ending up on thedailywtf, however. So now, how is “good code” different from “just code”? What characterizes code that wins our approval? In a word: simplicity. The smartest way of doing something is the simplest way, without missing any of the requirements. A simple solution is an elegant solution, isn’t it? Simplest often means shortest, too. The principle of simplicity also relates directly to the issue of complexity in a technical sense. High performance code is efficient because it’s the most lazy way to do the job. Inefficient code, conversely, does too much work — it’s for suckers.

What “good programming” is

This ingrained characteristic of programming is reflected very clearly in just about any discussion of code that is “too slow”. People critique the code for being awkward, for doing things in a round about manner. Eventually you arrive at a solution that is typically both shorter, and clearer. On the other end of the spectrum you have concepts like “beautiful code” and “code that stands the test of time”. And when you look at the code they’re raving about, the same observation transpires. It’s simple. It’s both blindingly obvious (once you get around to thinking about the problem in that particular way) and impressively simple for something *that* hard. It is the ultimate optimization of problem vs effort.

Our product smacks somewhat of mathematical proofs. In mathematics you score points for simple solutions, but it’s not strictly necessary. All it takes is for someone to read your proof and verify that it all fits together. No one is gonna run the proof on their machine a thousand times per second.

And that is what I’m driving at here. Programming is the activity of solving a problem such that the solution exerts the least amount of effort. It’s kind of funny that we of all people are dedicated to this particular discipline. Us, with the expensive silicone that can perform more operations than any other machine.

Set in those terms, programming is the art of doing as little as possible. And the great pieces of code are great not in what they *do* but in what they *don’t do*. In other words, if you write good code, it’s because you’ve found a way to take an input and do the least amount of work to produce the output. Baked into that is the secret of choosing your input very carefully in the first place. So if you can gain something from the form that the input is in, then you’re achieving something without writing any code for it. This is step 1 toward your brilliant piece of code.

Hidden complexity

But this is also when you start introducing complexity. Even if it’s external to your program, it is still an assumption that must hold. Is this good or bad? From your classical software engineering perspective, you badly want to minimize the amount of text you have to read to look at a piece of code and make sense of it. But then again, you need to know everything, because ignorance will bite you.

For example, in spiderfetch I spider a web page for urls. And it can run in a mode that will just output the urls and stop there. Now, if the urls are in the same order that they appear on the page, this is a big advantage, because the average web page can easily yield 50 urls and the user won’t be able to easily recognize them if they come up in some random order. But this is also too cosmetic an issue to be an explicit requirement. I certainly didn’t think of this particular issue when I started working on it. If you really wanted to document this kind of behavior down to the smallest detail, your documentation would be enormous. Pragmatically speaking, this behavior probably would not be documented.

Why is this an issue? Because giving a unique list of urls *is* a requirement which will influence this particular issue. (Hence, list(set(urls)) won’t do the trick).

Suppose you find a way to produce the desired behavior without doing any work (or doing very little). Should this be documented in order to make this bit of complexity explicit? If this added bit of complexity doesn’t affect the working of the function much at all, then it’s quite peripheral anyway. What are the risks? If you break the function then obviously the peripheral complexity doesn’t affect you. If you refactor you might break the peripheral bit, because it wasn’t written down anywhere. On other other hand, if all such peripheral bits were to be specified, it would take you that much longer to grok the code at all.

The message we send

The question we like to ask ourselves is: what happens to the person who inherits the code? Will he notice the “hidden” (or more precisely: incidental) desirable behavior? If not, is it really important enough to document it? And if yes, will he understand why it works that way? If you lose this behavior you haven’t broken the program. You have degraded it in a cosmetic way, but it still works well enough. So does it really need to be explicit?

The so-called clever coder that every middle manager is blogging his heart out about hiring, will, obvously, notice the hidden complexity. And know both how and why it’s there. The less clever coder might not notice. Or he might notice, but not understand the thought process behind it. What do we want to say to him? It’s okay if you mess this up, it’s not that important -or- Pay close attention to the detailed documentation or you might break something?

1. CPU: Intel Q9450
2. MB: Gigabyte GA-EP35-DS3R
3. Memory: Mushkin CL4 4Gb
4. HD: Western Digital WD5001ABYS
5. Case: Antec Sonata Plus 550
6.  Graphics: Gigabyte GeForce 8500GT Silent 512Mb

# Copyright 1999-2008 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

# $Header: $

inherit eutils qt4

DESCRIPTION="Slideshow Maker In Linux Environement"

HOMEPAGE="http://www.kde-apps.org/content/show.php/SMILE?content=83276"

SRC_URI="http://www.mandrivalinux-online.eu/manslide/${P}.tar.gz"

SLOT="0"

LICENSE="GPL-2"

KEYWORDS="~amd64"

IUSE=""

DEPEND=">=media-sound/sox-14.0.1

media-video/mplayer

( $(qt4_min_version 4.2.0) )

"

RDEPEND="${DEPEND}"

src_compile() {

cd smile && eqmake4 smile.pro

emake || die

}

src_install() {

dodir /usr/bin

exeinto /usr/bin

doexe smile/smile

make_desktop_entry Smile Smile smile "Qt;AUdioVideo;Video"

}

Ten days ago I complained that there were no good Lisp equivalents of ruby-forum or perlmonks. It looks like someone went and made one. What good timing.

I hope it's a success, and I hope it stays newb-friendly. The amount of fake watch and shoe spam on comp.lang.lisp has reached critical mass.

Speaking of mailing lists, maybe it's just me but I've never found mailing lists to be all that enjoyable to use. They have the benefit of being a sort of lowest common denominator (everyone has email, and you can slap an HTML interface on top of one). They also have the benefit of being distributed to some degree, because everyone who gets the email serves as an archive, and if the main server dies maybe you can recover things. And mailing lists do have less overhead than MBs when it comes to running one, especially a high-traffic one, I would imagine.

But the bad things about mailing lists vs. message boards:

• Message boards are accessible from anywhere that you have a web browser, which is everywhere. Email isn't necessarily accessible from everywhere, unless you use webmail or SSH home and use mutt or something, which not everyone can or wants to do. Or if there's a good web interface on the mailing list.
• You can't do anything more than plaintext, which isn't entirely a bad thing, HTML email is pure evil, but being able to cleanly post images or clickable links or formatted text on a message board is a nice feature.
• Threading never quite works correctly on mailing lists, because eventually someone will hit the wrong button in their mail client and break the thread; whereas on a message board it always works fine.
• You can move threads around between forums on an MB, you can edit threads, you can close threads, you can delete a post if you make a mistake; but mailing lists are write-only, and once you send a message off into the ether it's posted for everyone to see forever, and no one has much control over a list beyond moderating the messages that end up getting through.
• Avatars. Personal profiles. These things make people seem more like people and less like a nameless entity. It's friendlier and more inviting.
• The HTML interfaces people slap on top of mailing list archives are pretty horrible 95% of the time. Probably because most people are using email clients anyways so no one cares. Message boards generally look nice and have nice interfaces for reading and posting.
• Email sucks. Spam filters and bounced messages mean you never quite know if what you just wrote actually made it to the list. Reply to list vs. reply to sender vs. reply to all, etc. are all needless complications. How many times have you seen "UNSUBSCRIBE" sent to everyone on a list? The interface to mailing lists is not intuitive. Whereas you can always see immediately if an MB post worked or not.

And so on. I likes me my message boards.

apparently, there are some issues with linux 2.6 and pearpc.. so i still cant
get the gentoo ppc to start properly. i thought i’d do some studying in the
meantime..

typedef struct {
        volatile unsigned int slock;
} raw_spinlock_t;

static inline void __raw_spin_lock(raw_spinlock_t *lock)
{        asm volatile(\"\n1:\t\"
                     LOCK_PREFIX \" ; decb %0\n\t\"
                     \"jns 3f\n\"
                     \"2:\t\"
                     \"rep;nop\n\t\"
                     \"cmpb $0,%0\n\t\"
                     \"jle 2b\n\t\"
                     \"jmp 1b\n\"
                     \"3:\n\t\"
                     : \"+m\" (lock->slock) : : \"memory\");
}

interpretation of the extended inline asm:

1) : “+m” (locl->slock)
“+m” means that the memory operand ‘lock->slock’ is both input and output.

2) : “memory”
from gcc manual:
If your assembler instructions access memory in an unpredictable
fashion, add `memory’ to the list of clobbered registers. This will
cause GCC to not keep memory values cached in registers across the
assembler instruction and not optimize stores or loads to that memory.

3) LOCK_PREFIX is defined at /usr/src/linux/include/asm/alternative.h:

#define LOCK_PREFIX \
                \".section .smp_locks,\\"a\\"\n\"   \   ; push current section and change section to .smp_locks
                \"  .align 4\n\"                  \   ; align to 4 bytes
                \"  .long 661f\n\" /* address */  \   ; create an entry in the up/smp alternative locking table
                \".previous\n\"                   \   ; pop back the old section
                \"661:\n\tlock; \"                    ; assert processor LOCK# signal

LOCK_PREFIX is supposed to be called within the context of a procedure (executable) which finds its way to a .text section.

i haven’t digged down deep into the internals of ‘alternatives’ yet, but a quick look at kernel/alternative.c :: alternatives_smp_unlock() shows that it’s employing a self modifying code that patches the “lock” instruction with an architecture specific NOP opcode.

without all the extended asm semantics above, the asm roughly translates to:

1:      lock       ; decrement atomically
        decb    %0 ; really decrement now..
        jns     3f ; successful in acquiring lock?
2:      rep        ; nothing
        nop        ; nothing
        cmpb    $0, %0 ; someone must release the lock first.
        jle     2b     ; busy wait...
        jmp     1b     ; lock available! try acquiring lock again.
3:     ; exit __raw_spin_lock()

and then comes the trylock variant

static inline int __raw_spin_trylock(raw_spinlock_t *lock)
{
        char oldval;
        asm volatile(
                \"xchgb %b0,%1\"
                :\"=q\" (oldval), \"+m\" (lock->slock)
                :\"0\" (0) : \"memory\");
        return oldval > 0;
}

interpretation of the extended inline asm:

1) : “=q” (oldval)
output oldval in any a,b,c or d register.

2) : “+m” (locl->slock)
“+m” means that the memory operand ‘lock->slock’ is both input and output.

3) : “0″ (0)
%0 matches the output register for oldval. initialize that with the value 0.

4) : “memory”
from gcc manual:
If your assembler instructions access memory in an unpredictable
fashion, add `memory’ to the list of clobbered registers. This will
cause GCC to not keep memory values cached in registers across the
assembler instruction and not optimize stores or loads to that memory.

__raw_spin_trylock() basically exchanges the current value in raw_spinlock_t->slock with zero and returns true if locking was successful and false if acquiring of lock didn’t succeed.

lastly, we have the raw unlock procedure:

static inline void __raw_spin_unlock(raw_spinlock_t *lock)
{
        char oldval = 1;
	
        asm volatile(\"xchgb %b0, %1\"
                     : \"=q\" (oldval), \"+m\" (lock->slock)
                     : \"0\" (oldval) : \"memory\");
}

i haven’t been able to understand the significance of the “%b” in the assembler template but looking at the asm listing of the template with and without the %b yielded the same intructions, so could anyone shed some light on this one?

basically looks like __raw_spin_trylock(), but the difference is that oldval is now initialized to 1 instead of 0.

there are many variants stemming from the idea of this implementation. raw reader/writer locks which allows multiple readers but only one writer (with no concurrent readers). and then there’s the spinlock layer above the raw spinlock implementation.. but those are for another post.

’til then.

Coding at its most fun is exploratory. It’s exciting to try your hand at something new and see how it develops, choosing a route as you go along. Some poeple like to call this “expanding your ignorance”, to convey that you cannot decide on things you don’t know about, so first you have to become aware - and ignorant - of them. Then you can tackle them. If you want a buzzword for this I suppose you could call this “impulse driven development”.

spiderfetch was driven completely by impulse. The original idea was to get rid of awkward, one-time grep/sed/awk parsing to extract urls from web pages. Then came the impulse “hey, it took so much work to get this working well, why not make it recursive at little added effort”. And from there on countless more impulses happened, to the point that it would be a challenge to recreate the thought process from there to here.

Eventually it landed on a 400 line ruby script that worked quite nicely, supported recipes to drive the spider and various other gimmicks. Because the process was completely driven by impulse, the code became increasingly dense and monolithic as more impulses were realized. And it got to the point where the code worked, but was pretty much a dead end from a development point of view. Generally speaking, the deeper you go into a project, gradually the lesser the ideas have to be to be realized without major changes.

Introducing the web

The most disruptive new impulse was that since we’re spidering anyway, it might be fun to collect these urls in a graph and be able to do little queries on them. At the very least things like “what page did I find this url on” and “how did I get here from the root url” could be useful.

spiderfetch introduces the web, a local representation of the urls the spider has seen, either visited (spidered) or matched by any of the rules. Webs are stored, quite simply, in .web files. Technically speaking, the web is a graph of url nodes, with a hash table frontend for quick lookup and duplicate detection. Every node carries information about incoming urls (locations where this url was found) and outgoing urls (links to other documents), so the path from the root to any given url can be traced.

Detecting file types

Aside from the web impulse, the single biggest flaw in spiderfetch was the lack of logic to deal with filetypes. Filetypes on the web work pretty much as well as they do on your local computer, which means if you rename a .jpg to a .gif, suddenly it’s not a .jpg anymore. File extensions are a very weak form of metadata and largely useless. Just the same with spidering, if you find a url on a page you have no idea what it is. If it ends in .html then it’s probably that, but it can also not have an extension at all. Or it can be misleading, which when taken to perverse lengths (eg. scripts like gallery), does away with .jpgs altogether and encodes everything as .php.

In other words, file extensions tell you nothing that you can actually trust. And that’s a crucial distinction: what information do I have vs what can I trust. In Linux we deal with this using magic. The file command opens the file, reads a portion of it, and scans for well known content that would identify the file as a known type.

For a spider this is a big roadblock, because if you don’t know what urls are actual html files that you want to spider, you have to pretty much download everything. Including potentially large files like videos that are a complete waste of time (and bandwidth). So spiderfetch brings the “magic” principle to spidering. We start a download and wait until we have enough of the file to check the type. If it’s the wrong type, we abort. Right now we only detect html, but there is a potential for extending this with all the information the file command has (this would involve writing a parser for “magic” files, though).

A brand new fetcher

To make filetype detection work, we have to be able to do more than just start a download and wait until it’s done. spiderfetch has a completely new fetcher in pure python (no more calling wget). The fetcher is actually the whole reason why the switch to python happened in the first place. I was looking through the ruby documentation in terms of what I needed from the library and I soon realized it wasn’t cutting it. The http stuff was just too puny. I looked up the same topic in the python docs and immediately realized that it will support what I want to do. In retrospect, the python urllib/httplib library has covered me very well.

The fetcher has to do a lot of error handling on all the various conditions that can occur, which means it also has a much deeper awareness of the possible errors. It’s very useful to know whether a fetch failed on 404 or a dns error. The python library also makes it easy to customize what happens on the various http status codes.

A modular approach

The present python code is a far cry from the abandoned ruby codebase. For starters, it’s three times larger. Python may be a little more verbose than ruby, but the increase is due to a new modularity and most of all, new features. While the ruby code had eventually evolved into one big chunk of code, the python codebase is a number of modules, each of which can be extended quite easily. The spider and fetcher can both be used on their own, there is the new web module to deal with webs, and there is spiderfetch itself. dumpstream has also been rewritten from shellscript to python and has become more reliable.

Grab it from github:

spiderfetch-0.4.0

One of the great things about Qt is that you can compile the code under esoteric OSs (mmh?) like Windows or MacOS. Although I’ve almost never used windows, I did the packaging of yzis. I used the Nullsoft Installer, which is ok.

I had several issues with static linking, and thought maybe some of you could give some help about it. Don’t ask why I want static link, this is not the issue here.

Problem #1:

The most important one is Qt itself. I expected that to be easy, but it is not. The FindQt4 shipped with cmake 2.4.8 or 2.6 is not really aware of static lib, or is it ? Nor is the one from kde svn. I’ve tried using the one from quassel-irc, but it fails as well. If you can help me with this, the code is available.

It seems (according to #qt on irc) that it makes sense to have two different Qt installed, one static and one shared. I did that (double the space used…) and in one of them did “configure -static” and recompiled qt. Now the *.a are much bigger, and though qyzis links against those *.a, it still depends on the DLLs, according to “dependencies walker”. Gr…

Problem #2:

Then, there is the problem of gnuwin32 tools. In the lib/ directory, you can find for example

• libintl.dll.a
• libintl.def
• libintl.lib

And the DLL (libintl3.dll) is in the bin/ directory. I need to ship the DLL with qyzis, because cmake found the dll, and linked against libintl.dll.a. In a perfect world, I would like cmake to use the libintl.lib and have a static link, but i dont know how to convince cmake of doing that. Do you know ?

Problem #3:

How do you find out what kind of library a file is ? According to what I’ve found googling the web, libraries can have a wild number of different names (libX.dll, libX.dll.a, libX.lib, libX.a, all of this without the lib prefix and so on…). Even worse : libX.a for example, could be either a static lib or the stub for the DLL. Do you have clarifications about this ? Do you know of a reliable way to know which kind of library it is ? (DLL, DLL stub, or purely static).

Ok, here it is, things have finally settled and we are happy to bring you the first alpha release for Yzis. The foundations are stabilizing, and we are now focusing on fixing bugs and porting to different architectures, OSs, and interfaces.

What you have so far :

• nyzis (curses frontend) working under linux.
• qyzis (Qt frontend) working under linux and windows.
• A windows installer.
• All tests (both unit tests and lua/script tests) pass.
• Most important bugs in the bugtracker fixed.

The most noteworthy missing feature is the KDE embeddable component, we are aware of this, and this is the main thing we shall work on after 1.0 is out.

At this point, we are not yet asking for broad testing, but developers not afraid of bleeding edge are encouraged to test it out. If you can help with porting/solving bugs, this is of course even better.

You can join us on #yzis on freenode to discuss all of this.

The web site has been updated, and you should find information about getting the source from source control (mercurial) and compiling on most platforms.

http://www.yzis.org

The tarballs and the windows installer can be downloaded from this url:

http://labs.freehackers.org/projects/list_files/yzis

Below are some screenshots showing the different interfaces (qt/linux, ncurses, qt/windows):

I’ve been pushing some new photography to my photoblog over at Sumatro.com.  I have a new set of work lined up, all being published at 9am every morning.  To keep up to date, subscribe to the RSS feed.

Would love some comments/idea/abuse on the photos if you have the time.

Python

PHP

Ruby On Rails

Django

Are you ‘up to date’ if you are still using a static webpage today? I wouldn’t say that there is a global answer to that question and everybody’s got to find out for himself.

Usually I’m a big fan of automatism and technology and its advantages - but is it really worth it? Let’s have a closer look at the topic:

A Content Management System (CMS) is a program, running on your webserver, generating the html output for the visitors browser, which is actually a good thing, if things are changing a lot.

But a CMS is just a piece of software that needs updates and patches too, disregarding new features and stuff as there might be undiscovered security holes which might turn out to be a rather serious problem. I don’t want to question any cms here. I just want to make you think if you really need one.

I’ll give you an example: My domain stargazer.at hosts a portal page, offering links to my services, my blog, whatever. As my services don’t change that often, there is no need for dynamical created content as things just don’t change. If I think back, the last update on the portal page happened four month ago. Since then it wasn’t touched anymore. Regarding security, this would be quite fatal. In the other hand, my blog here gets much more love and changes much more often. That’s why I am using Wordpress here and plain html on my portal page.

Nick was home from college this past week, and I took a lot of time away from working on the blog and BIOSLEVEL to spend some time with friends. It was a good time for sure, but I always come to regret it when I realize how little work I've done.

Hopefully I get things back on track over the next few days. I'm way behind on several reviews for BIOSLEVEL, and some of the products were just released in the last two weeks or so.

I also rebuilt two of my computers in to new housing, with a few new components that were sent to me for review. Let me say that I hate reviewing some CPU coolers. A certain company that will go unnamed for now sent two CPU coolers that otherwise seem impossible to install on an Intel machine. Stay tuned for a review, if I ever get them installed.

On top of all that, I somehow started playing World of Warcraft again.

There's an article on Slashdot about a US Senate hearing on laptop seizures at border crossings. This affects me, because I travel to Canada a lot and plan to move there within a year or so.

It's a problem because my job requires me to handle what amount to people's medical records as data files on my laptop. It's part of my job, and often I work from home. As of right now, I never take my laptop with me to Canada partly because I don't know what would happen if a border agent decided to inspect or copy all of my data. I can get in very serious trouble for breaching patient confidentiality. On the other hand I could get in serious trouble if I refused to allow a search for myself; at best I'd be turned way at the border, having wasted hundreds of dollars to travel there.

I really don't know what I'm going to do when I move. I'll probably have to wipe my computers clean before shipping them up there. Another option would be to encrypt all the data, upload it to the server that hosts my website, then download it all again after I move. It's insane that I'd have to do such a thing though. And shuffling sensitive data around to strangers' computers and servers isn't the safest thing in the world either.

How do lawyers and doctors and people with trade secrets and other people with classified or legally protected information handle border crossings? It's a bit of a conflict of interest.

Ok, I hinted that I would do a more thorough review of GitHub, the new and easy-to-use git repository hosting site. Although I’m still no power-user I’ve come to know the features that make GitHub worth using and so far unique.
The “Fork” feature is probably the most important one. Instead of just cloning a repository and working on it locally, you can fork it on GitHub. When you fork a project everyone can see you did, and has a nice flashy graph-view so they can see where you branched and what commits you made that are not (yet) in the upstream. And if you have introduced changes that you think would benefit the project you can send people (e.g. the original project owner) a “pull-request”. The recipient can then easily fetch/merge your changes into his project. It really doesn’t get much easier to contribute to (open-source) projects. I certainly did for the first time ;)

Then there are feeds. You can watch projects, which means that your feed includes any commits/comments on the watched projects. It goes without saying that this can be quickly overwhelming for active projects. Comments can be made on specific lines in a commit (or on the whole commit), which is a great feature (think of it as the equivalent to patches being discussed line-by-line in mailing-lists). I still prefer mails though ;)
The syntax-highlighting looks pretty good. I’ve already mentioned the very pale interface (as in low-contrast) and it still has not changed. But I think that most people really browse the commit history in their local clones anyway.
Each project has an attached Wiki too, so you can add a few pages (or a lot if you wish).
To conclude I can say that GitHub is a great service, since it has a free plan for public projects. I would not need it for my personal projects, but to run a or contribute to a open-source project it’s perfect. The amount you use its features is up to you. If you already have a Wiki, already have an active mailing-list and discuss patches there too then you can just use GitHub as the central source code repository (plus the forks of course). The real work is done on your local repository with git anyway, but y’already knew that I guess ;)

So the other day I was thinking what a pain it is to handle text in input boxes on web pages, especially when you’re writing something longer. Since I started using vim for coding I’ve become aware of how much more efficient it is to edit when you have keyboard shortcuts to accelerate common input operations.

I discovered a while back that bash has input modes for both vi and emacs and ever since then editing earlier commands is so much easier. And not only does it work in bash, but just as well in anything else, like ipython, irb, whatever.

So now only Firefox remains of my most used applications that still has the problem of stoneage editing, and I’m stuck using the mouse way too much. It bugs me that I can’t do Ctrl+w to kill a word. Thus I went hunting for an emacs extensions and what do you know, of course there is one: Firemacs. Turns out it works well, and it also has keyboard shortcuts for navigation. > gets you to the bottom of the page, no more having to hold down <space>.

Nvidia reiterated that it won’t provide open source drivers for Linux because the company claims there is no need for it.

I had to install amsn just so could video chat with a friend on MSN. Really? On the plus side, at least I could do it :)

Also, figured out how to use skype on Ubuntu. Skype really want /dev/dsp. And Ubuntu now uses pulseaudio. So basically if you've done anything with sound, Skype won't be able to get the sound. Which sucks. However, pulse audio ships with this handy utility 'pasuspender' which temporarily suspends pulse audio and it's lock on /dev/dsp. So to actually use skype

pasuspender skype

And skype can then seize and monopolize the sound card. So you can use it, but no other sound till you shut Skype down. So it's 2008 and we still can't share the sound card :/.

I just found a couple cool programs called turbotail and multitail while searching for rbot using eix.

Turbotail is just like tail, but it uses dnotify instead of auto refreshing a defined number of seconds.  I always thought it was kind of silly to keep refreshing the screen searching for new content with tail.  Turbotail just sits there until the kernel notifies of a change in the file that you are tail’ing and then it updates what you see.

Multitail looks like a VERY robust way of viewing multiple files.  It can tail any number of files and supports text filtering and even syntax highlighting.

Turbotail works great, but unfortunately multitail crashes when I try to run it from my Yakuake console.  I get this:

--*- multitail 5.2.0 (C) 2003-2007 by folkert@vanheusden.com -*--
 
A problem occured at line 511 in function mynewwin (from file term.c):
 
Failed to create window with dimensions 55x9 at offset -27,-4 (terminal size: 167,19)

Seems to work just fine from a regular console though.  It will take me a while to actually learn all of the features of multitail.

After a while of looking for a new job, I finally got a new job. Well, actually, I’ve been working my new job for about 3 months now. So… I guess it’s not really a new job anymore.

I’m now a full time Linux administrator with ExLibris. Unfortunately, Red Hat is the preferred distribution. That’s to be expected. Most business want to make sure they use something that’s proven and has a clear line of support.

The new job is in Des Plaines, Il, which means I’ll have to sell my house and move a little closer. So far, the job seems pretty good. It’s doing something I like and the people are nice, and most of them seem pretty smart.

Inevitably, as you’re learning a new skill, such as a programming language, you may want to revisit your old work and see if you can do it better. I had this pair of functions to fetch the previous and the next “page” of a source collection, based on the sort order of the source. In plain text, in order to get to the previous “page” I want the source with the maximum sort order smaller than the present one, and with the same parent id. Here is my brute-force approach from a couple of years ago:

CREATE OR REPLACE FUNCTION get_prev_page(INTEGER) RETURNS INTEGER AS $$
DECLARE
    self_page INTEGER;
    prev_page INTEGER;
    prev_src INTEGER;
    par_id INTEGER;
BEGIN
    SELECT parent_id FROM sources INTO par_id WHERE source_id = $1;
    SELECT sort_order FROM sources INTO self_page
        WHERE source_id = $1;
    SELECT MAX(sort_order) FROM sources INTO prev_page
        WHERE parent_id = par_id AND sort_order < self_page;
    SELECT source_id FROM sources INTO prev_src
        WHERE parent_id = par_id AND sort_order = prev_page;
    RETURN COALESCE(prev_src,0);
END;
$$ LANGUAGE plpgsql STABLE;

Ugly, ugly, ugly. I remember what was the main stumbling block here: You can’t use an aggregate function such as MAX() in a WHERE clause. The thing is that you don’t need all those assignments. A little code folding, replacing variables with sub-selects, takes you a long way:

CREATE OR REPLACE FUNCTION get_prev_page(INTEGER) RETURNS INTEGER AS $$
DECLARE
    pp INTEGER;
BEGIN
    SELECT source_id INTO pp FROM sources
        WHERE parent_id = (SELECT parent_id FROM sources WHERE source_id = $1)
        AND sort_order < (SELECT sort_order FROM sources WHERE source_id = $1)
        ORDER BY sort_order DESC LIMIT 1;
    RETURN COALESCE(pp, 0);
END
$$ LANGUAGE plpgsql STABLE;

The “ORDER BY sort_order DESC LIMIT 1″ is a great idiom whenever you need to use an extreme value as part of a WHERE clause.

Even if the two versions of the code above are functionally equivalent, and the PostgreSQL planner probably will rewrite the query to something like version 1, most programmers would prefer version 2. Why? I think there’s a lot to the concept that “coding is poetry”. Version 2 is more esthetically pleasing, because it conveys its inner meaning in a much more succinct way, as in the Merriam-Webster definition of the word succinct: “marked by compact precise expression without wasted words”. At least to me it does. And that’s probably some of the essence of poetry.