Umstellung der Feeds auf Atom

26. Juli 20100 Kommentare

Ein kleiner Hinweis in eigener Sache. Von nun an werden sämtliche Feeds auf blogeum nur noch im Atom-Format statt RSS 2.0 angeboten. Wer also noch keinen Atom-fähigen Feedreader sein Eigen nennt, sollte spätestens jetzt ein Upgrade in Betracht ziehen :-).

Was mich dazu bewogen hat? Nun, zum einen hatte ich in letzter Zeit Probleme mit einigen Blogdiensten wie BlogPingR.de und Bloggerei. Zum anderen hat mir der Artikel von Sam Ruby (deutsche Übersetzung von Jens Meiert) die Augen geöffnet. Atom bietet standardmäßig einfach viel mehr Möglichkeiten als RSS. Zugegeben, beide lassen sich über Namespaces erweitern. Aber warum sollte ich RSS erweitern, wenn Atom schon alles an Bord hat, was ich brauche?

Wer eine andere Meinung dazu hat oder mich zu meinem Entschluss beglückwünschen will *g*, kann dies gerne in einem Kommentar tun.

„Umstellung der Feeds auf Atom“ weiterlesen …

atom, intern, rss

10 Tipps zu jQuery

26. Juli 20100 Kommentare

Durch Peter Kröner bin ich auf eine interessante Präsentation von Paul Irish gestoßen. In der Präsentation weist Paul auf 10 Dinge hin, die ihm beim Durchlesen der jQuery-Source aufgefallen sind.

Ich kann jedem Interessierten nur empfehlen sich das Video anzuschauen.

Im Folgenden möchte ich auf ein paar Dinge hinweisen, die ich auch noch nicht kannte und die mir speziell aufgefallen sind:

Selbstaufrufende Funktionsdefinition

(function myfunc(param) {

    // Funktionsrumpf hier einfügen

})(myvar);

In obigem Code wird eine (anonyme) Funktion namens myfunc(param) erstellt, die direkt im Anschluss mit dem Parameter myvar aufgerufen wird.

Zeitgesteuerte Wiederholungen

Wenn man ein Ereignis oder eine Funktion nach einer bestimmten Zeitspanne immer wieder wiederholen will, gibt es in JavaScript die Methode setInterval(func, delay). Nachteilig ist aber, dass die Funktion funcimmer nach der Ablauf der Zeitspanne delay aufgerufen wird, egal ob func längere Zeit zur Ausführung benötigt als delay. So kann es zum „Stau“ kommen.

setInterval(function() {
    myfunc();
}, 100);

Wenn myfunc() im Beispiel länger als 100 Millisekunden zur Ausführung benötigt, wird trotzdem nach 100 Millisekunden myfunc() erneut aufgerufen, usw. Doch mit der eben definierten selbstaufrufenden Funktionsdefinition kann man dem entgegenwirken:

(function myloop() {

    myfunc();
    setTimeout(myloop, 100);

})();

myfunc() wird nun erst vollständig abgearbeitet und erst dann nach einer Wartezeit von 100 Millisekunden wird myloop() und damit myfunc() erneut aufgerufen.
Einen Nachteil hat die Lösung aber trotzdem in meinen Augen: myloop() wird rekursiv aufgerufen und erzeugt dadurch natürlich einen Overhead der bei häufiger periodischer Ausführung nicht zu unterschätzen ist.

Elementfilter

In jQuery lassen sich relativ einfach alle Elemente eines bestimmten Typs finden. $(':password') findet beispielsweise alle Passwortfelder. Doch diese Methode ist sehr langsam, weil per Definition alle Elemente innerhalb des DOM durchgegangen werden und geprüft wird, ob die Elemente vom Typ password sind (also quasi $('*:password')).
Beschleunigen lässt sich das ganze, indem man ein wenig spezifischer wird. Den Typ password können nur Input-Felder haben. Also ist es sinnvoll, die Auswahl ein wenig einzuschränken. $('input:password') sucht nur nach Input-Felder vom Typ password, was wesentlich schneller ist.

Das Gleiche gilt auch für die Filter text, radio, checkbox, file, password, submit, image, reset und button.

JSON-Parsing

JavaScipt Object Notation ist ein einfaches Datenaustauschformat auf der Basis von anonymen JavaScript-Objekten. In JavaScript kann man so ein JSON-Objekt theoretisch einfach über eval() auswerten. Aber wie die sicherheitsbewussten unter euch wissen, ist eval() evil!
jQuery nutzt deshalb nativ die browsereigenen JSON-Parsing-Methoden. Für den Fall, dass diese nicht existieren (bspw. in älteren Browsern), haben sich die jQuery-Entwickler eine andere trickreiche Implementierung überlegt, ohne auf eval() zurückgreifen zu müssen:

var x = (new Function('return ' + jsonobj))()

Es wird schlicht ein neues Funktionsobjekt erzeugt, welches dann das JSON-Objekt zurückgibt. Auf diese Weise haben wir auch JSON geparsed, aber ohne Sicherheitsbedenken. Denn im Gegensatz zu eval() darf das Funktionsobjekt nur auf seinen eigenen Namensraum und Gültigkeitsbereich zugreifen und nicht auf den globalen. Daher kann es nicht zum Überschreiben von Variablen, Objekten, usw. kommen. Trickreich, stimmt’s?

jQuery-Performance

Abschließend möchte ich auch noch auf einen Vortrag von Paul Irish zum Thema „jQuery Anti-Patterns for Performance & Compression“ hinweisen, der einiges noch einmal aufgreift und vertieft. Für jeden jQuery-Entwickler ein Muss!

„10 Tipps zu jQuery“ weiterlesen …

code, funktion, javascript, jquery, linktipp, optimierung, performance

CSS und JavaScript-Minifier

16. Juli 20100 Kommentare

Heute werde ich wieder einmal eine nützliche PHP-Funktion vorstellen. Genauer gesagt handelt es sich um eine Klasse, die CSS und JavaScript komprimieren kann. Bei diesem Minification (oder minify) genannten Prozess, werden unnötige Kommentare, Leerzeichen, Tabulatoren und Zeilenumbrüche entfernt, wodurch die Datei kleiner wird und so schneller an den Benutzer übertragen werden kann. Zusätzlich kann in der Klasse der „bereinigte“ Quellcode auch noch vor der Übertragung mit gzip oder Deflate komprimiert werden, damit er noch schneller übertragen werden kann.

<?php
/* minifier.class.php */

class minifier {

    public function minify_CSS($str, $zip = FALSE) {
        # Zeilenumbrüche und Tabulatoren entfernen
        $str = str_replace(array("\r", "\n", "\t"), '', $str);

        # Kommentare entfernen
        $str = preg_replace('#/\*(.*)\*/#U', '', $str);

        # Header setzen
        header('Content-Type: text/css; charset=UTF-8');
        header('Cache-Control: public, max-age=1209600');

        if($zip === TRUE)
            $str = $this->zip($str);

        echo $str;
    }


    public function minify_JS($str, $zip = FALSE) {
        # Einzeilige Kommentare entfernen
        $str = preg_replace('#//.*#', '', $str);

        # Zeilenumbrüche und Tabulatoren entfernen
        $str = str_replace(array("\r", "\n", "\t"), '', $str);

        # Mehrzeilige Kommentare entfernen
        $str = preg_replace('#/\*(.*)\*/#U', '', $str);

        # Header setzen
        header('Content-Type: text/javascript; charset=UTF-8');
        header('Cache-Control: public, max-age=1209600');

        if($zip === TRUE)
            $str = $this->zip($str);

        echo $str;
    }


    protected function zip($str) {
        if(isset($_SERVER['HTTP_ACCEPT_ENCODING']) === TRUE) {

            # Welche Verfahren werden unterstützt?
            if(stripos($_SERVER['HTTP_ACCEPT_ENCODING'], 'deflate') !== FALSE) {

                # Komprimieren mit Deflate-Verfahren
                header('Content-Encoding: deflate');
                $str = gzdeflate($str, 9);
            } elseif(stripos($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip') !== FALSE) {

                # Komprimieren mit gzip-Verfahren
                header('Content-Encoding: gzip');
                $str = gzencode($str, 9);
            }
        }

        return $str;
    }
}
?>

Die Klasse kann dann in einer beliebigen Datei so aufgerufen werden:

<?php
require_once('minifier.class.php');

$min = new minifier();

# JavaScript komprimieren
$min->minify_JS('[JavaScript-Quellcode]', TRUE);

# CSS komprimieren
$min->minify_CSS('[CSS-Quellcode]', TRUE);
?>

Im Gegensatz zu vielen anderen Minifiern habe ich versucht die Optimierungen „leichtgewichtig“ zu gestalten, also einen Kompromiss aus Bandbreiteneinsparung und Ressourcenschonung zu finden. Viele andere Minifier nehmen nämlich noch mehr Optimierungen vor (Variablenumbenennung, komplizierte RegEx-Konstrukte), die viel Rechenzeit benötigen und daher nur bedingt für die On-the-fly-Erstellung von komprimiertem Code geeignet sind. Sicherlich lassen sich damit die Dateigrößen teils erheblich weiter reduzieren aber auf Kosten der serverseitigen Performance.

Auf blogeum wird die Klasse in einer erweiterten Form auch eingesetzt, um CSS und JS vor der Übertragung zu verkleinern und die Übertragungszeiten zu vermindern.

Wie immer steht der Code unter einer Creative Commons-Lizenz.

„CSS und JavaScript-Minifier“ weiterlesen …

code, css, javascript, optimierung, performance, php, programmieren, schnipsel

Zufallswerte schneller erzeugen in Linux

11. Juli 20100 Kommentare

Wer des Öfteren mit Linux innerhalb einer virtuellen Maschine (bspw. VirtualBox) arbeitet und dabei auf Programme setzt die Zufallswerte benötigen, ist wahrscheinlich schon einmal auf ein spezielles Problem gestoßen: Das Programm stellt die Arbeit ein, weil nicht genügend Zufallsdaten vorhanden sind und setzt sie erst wieder fort, wenn genügend Entropie gesammelt wurde.
Zum Sammeln von Entropie werden meistens Mausbewegungen oder Tastatureingaben herangezogen, weil diese nicht vorhersagbar sind. Weiterhin kann auch eine statistische Rauschquelle herangezogen werden.
Kurioserweise scheint dies in einer virtuellen Maschine nicht einwandfrei zu funktionieren. Das Problem kann auch bei einer Remote-Verbindung zu einem Rechner (per SSH) auftreten, weil Mausbewegungen natürlich nicht mit übertragen werden.

Unter Linux kann man dem Abhilfe schaffen, indem man ein kleines Programm mit dem Namen rngd einsetzt.
Ein Auszug aus der Manpage zu rngd:

This daemon feeds data from a random number generator to the kernel's random number entropy pool, after first checking the data to ensure that it is properly random. http://linux.die.net/man/8/rngd

rngd kann man unter Debian-basierenden Linux-Distributionen wie Ubuntu einfach über

sudo apt-get install rngd

installieren. Anschließend sagt man dem Tool noch, dass es seine Entropiedaten aus dem Linux-eigenen Zufallsgenerator beziehen soll:

rngd -r /dev/urandom

Danach kann man das Programm, welches viele Zufallsdaten benötigt einwandfrei und ohne entropiebedingte Unterbrechungen ausführen.

Konkret ist dieses Problem bei mir beim Erzeugen von OpenPGP-Schlüsseln aufgetreten. Mit rngd konnte ich das Problem jedoch beseitigen.

„Zufallswerte schneller erzeugen in Linux“ weiterlesen …

linux, openpgp, server, verschluesselung, zufall

PHP-Funktion für Wake-on-LAN

09. Juni 20100 Kommentare

Mal wieder eine kleine aber feine PHP-Funktion. Diesmal geht es darum, einen Rechner per Wake-on-LAN-Signal (WOL) über das Netzwerk aufzuwecken. Prinzipiell muss dazu nur eine Verbindung zu einem anderen Rechner im Netzwerk oder einem Router aufgebaut werden, der dann das entsprechende Signal im Netzwerk herumschickt und so den gewünschten Computer aufweckt, sobald dieser das Signal empfängt.

Das Signal ist relativ einfach aufgebaut: 6 Mal der Hexwert FF und anschließend 16 Mal die MAC-Adresse der Netzwerkkarte des zu weckenden Rechners. Dieses sogenannte MagicPacket wird via UDP an Port 0, 7 oder 9 gesendet.

Wenn man die IP-Adresse des Routers nicht kennt, kann auch ein Broadcast (Signal an alle Geräte im Netzwerk) gesendet werden, sofern der Router dies zulässt.

<?php
# MAC-Adresse des zu weckenden Rechners
$mac = '00:00:00:00:00:00';
# IP des Routers (255.255.255.255 für Broadcast)
$ip = 'udp://255.255.255.255';

function wakeup($mac, $router) {
    if(strlen($mac) !== 17)
      return FALSE;

    if(filter_var($router, FILTER_VALIDATE_URL) === FALSE)
      return FALSE;

    $raw = sscanf($mac, '%2x:%2x:%2x:%2x:%2x:%2x');
    $func = create_function('$v', 'return isset($v);');
    $raw = array_filter($raw, $func);

    if(sizeof($raw) !== 6)
      return FALSE;


    # Router-Verbindung aufbauen auf Port 9 mit 4 Sekunden Timeout
    $fp = fsockopen($router, 9, $errnum, $errstr, 4);

    if(is_resource($fp) === FALSE) {
        trigger_error('['.$errnum.'] '.$errstr, E_USER_ERROR);
        return FALSE;
    }


    # Beginn des MagicPacket
    $magicp = "\xFF\xFF\xFF\xFF\xFF\xFF";

    # MAC in ASCII-Zeichen umwandeln
    $hexmac = '';
    foreach($raw AS $c) {
        $hexmac .= chr($c);
    }

    # 16 Mal MAC an MagicPacket anhängen
    $magicp .= $hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac.$hexmac;

    fwrite($fp, $magicp);
    fclose($fp);

    printf('Wake-Up-Signal an %02X:%02X:%02X:%02X:%02X:%02X übertragen!', $raw[0], $raw[1], $raw[2], $raw[3], $raw[4], $raw[5]);
    return TRUE;
}

wakeup($mac, $ip);
?>